﻿using System;
using System.ComponentModel;

namespace HalconDotNet
{
	/// <summary>Represents an instance of an XLD contour object(-array).</summary>
	// Token: 0x02000073 RID: 115
	[Serializable]
	public class HXLDCont : HXLD
	{
		/// <summary>Create an uninitialized iconic object</summary>
		// Token: 0x06001BDF RID: 7135 RVA: 0x000ABEF9 File Offset: 0x000AA0F9
		public HXLDCont() : base(HObjectBase.UNDEF, false)
		{
		}

		// Token: 0x06001BE0 RID: 7136 RVA: 0x000ABF07 File Offset: 0x000AA107
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDCont(IntPtr key) : this(key, true)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001BE1 RID: 7137 RVA: 0x000ABF1D File Offset: 0x000AA11D
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDCont(IntPtr key, bool copy) : base(key, copy)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001BE2 RID: 7138 RVA: 0x000ABF33 File Offset: 0x000AA133
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HXLDCont(HObject obj) : base(obj)
		{
			this.AssertObjectClass();
			GC.KeepAlive(this);
		}

		// Token: 0x06001BE3 RID: 7139 RVA: 0x000ABF48 File Offset: 0x000AA148
		private void AssertObjectClass()
		{
			HalconAPI.AssertObjectClass(this.key, "xld_cont");
		}

		/// <summary>Returns the iconic object(s) at the specified index</summary>
		// Token: 0x17000066 RID: 102
		public HXLDCont this[HTuple index]
		{
			get
			{
				return this.SelectObj(index);
			}
		}

		// Token: 0x06001BE5 RID: 7141 RVA: 0x000ABF63 File Offset: 0x000AA163
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static int LoadNew(IntPtr proc, int parIndex, int err, out HXLDCont obj)
		{
			obj = new HXLDCont(HObjectBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		/// <summary>
		///   Generate XLD contours from regions.
		///   Modified instance represents: Resulting contours.
		/// </summary>
		/// <param name="regions">Input regions.</param>
		/// <param name="mode">Mode of contour generation. Default: "border"</param>
		// Token: 0x06001BE6 RID: 7142 RVA: 0x000ABF7C File Offset: 0x000AA17C
		public HXLDCont(HRegion regions, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(70);
			HalconAPI.Store(proc, 1, regions);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(regions);
		}

		/// <summary>
		///   Generate an XLD contour from a polygon (given as tuples).
		///   Modified instance represents: Resulting contour.
		/// </summary>
		/// <param name="row">Row coordinates of the polygon. Default: [0,1,2,2,2]</param>
		/// <param name="col">Column coordinates of the polygon. Default: [0,0,0,1,2]</param>
		// Token: 0x06001BE7 RID: 7143 RVA: 0x000ABFD4 File Offset: 0x000AA1D4
		public HXLDCont(HTuple row, HTuple col)
		{
			IntPtr proc = HalconAPI.PreCall(72);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, col);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(col);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the union of cotangential contours.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="fitClippingLength">Length of the part of a contour to skip for the determination of tangents. Default: 0.0</param>
		/// <param name="fitLength">Length of the part of a contour to use for the determination of tangents. Default: 30.0</param>
		/// <param name="maxTangAngle">Maximum angle difference between two contours' tangents. Default: 0.78539816</param>
		/// <param name="maxDist">Maximum distance of the contours' end points. Default: 25.0</param>
		/// <param name="maxDistPerp">Maximum distance of the contours' end points perpendicular to their tangents. Default: 10.0</param>
		/// <param name="maxOverlap">Maximum overlap of two contours. Default: 2.0</param>
		/// <param name="mode">Mode describing the treatment of the contours' attributes. Default: "attr_forget"</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001BE8 RID: 7144 RVA: 0x000AC034 File Offset: 0x000AA234
		public HXLDCont UnionCotangentialContoursXld(double fitClippingLength, HTuple fitLength, double maxTangAngle, double maxDist, double maxDistPerp, double maxOverlap, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(0);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, fitClippingLength);
			HalconAPI.Store(proc, 1, fitLength);
			HalconAPI.StoreD(proc, 2, maxTangAngle);
			HalconAPI.StoreD(proc, 3, maxDist);
			HalconAPI.StoreD(proc, 4, maxDistPerp);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(fitLength);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the union of cotangential contours.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="fitClippingLength">Length of the part of a contour to skip for the determination of tangents. Default: 0.0</param>
		/// <param name="fitLength">Length of the part of a contour to use for the determination of tangents. Default: 30.0</param>
		/// <param name="maxTangAngle">Maximum angle difference between two contours' tangents. Default: 0.78539816</param>
		/// <param name="maxDist">Maximum distance of the contours' end points. Default: 25.0</param>
		/// <param name="maxDistPerp">Maximum distance of the contours' end points perpendicular to their tangents. Default: 10.0</param>
		/// <param name="maxOverlap">Maximum overlap of two contours. Default: 2.0</param>
		/// <param name="mode">Mode describing the treatment of the contours' attributes. Default: "attr_forget"</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001BE9 RID: 7145 RVA: 0x000AC0BC File Offset: 0x000AA2BC
		public HXLDCont UnionCotangentialContoursXld(double fitClippingLength, double fitLength, double maxTangAngle, double maxDist, double maxDistPerp, double maxOverlap, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(0);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, fitClippingLength);
			HalconAPI.StoreD(proc, 1, fitLength);
			HalconAPI.StoreD(proc, 2, maxTangAngle);
			HalconAPI.StoreD(proc, 3, maxDist);
			HalconAPI.StoreD(proc, 4, maxDistPerp);
			HalconAPI.StoreD(proc, 5, maxOverlap);
			HalconAPI.StoreS(proc, 6, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a contour in polar coordinates back to Cartesian coordinates
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to map the column coordinate 0 of PolarContour to. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to map the column coordinate $WidthIn-1$ of PolarContour to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to map the row coordinate 0 of PolarContour to. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to map the row coordinate $HeightIn-1$ of PolarContour to. Default: 100</param>
		/// <param name="widthIn">Width of the virtual input image. Default: 512</param>
		/// <param name="heightIn">Height of the virtual input image. Default: 512</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <returns>Output contour.</returns>
		// Token: 0x06001BEA RID: 7146 RVA: 0x000AC13C File Offset: 0x000AA33C
		public HXLDCont PolarTransContourXldInv(HTuple row, HTuple column, double angleStart, double angleEnd, HTuple radiusStart, HTuple radiusEnd, int widthIn, int heightIn, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.Store(proc, 4, radiusStart);
			HalconAPI.Store(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, widthIn);
			HalconAPI.StoreI(proc, 7, heightIn);
			HalconAPI.StoreI(proc, 8, width);
			HalconAPI.StoreI(proc, 9, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radiusStart);
			HalconAPI.UnpinTuple(radiusEnd);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a contour in polar coordinates back to Cartesian coordinates
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to map the column coordinate 0 of PolarContour to. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to map the column coordinate $WidthIn-1$ of PolarContour to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to map the row coordinate 0 of PolarContour to. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to map the row coordinate $HeightIn-1$ of PolarContour to. Default: 100</param>
		/// <param name="widthIn">Width of the virtual input image. Default: 512</param>
		/// <param name="heightIn">Height of the virtual input image. Default: 512</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <returns>Output contour.</returns>
		// Token: 0x06001BEB RID: 7147 RVA: 0x000AC1F4 File Offset: 0x000AA3F4
		public HXLDCont PolarTransContourXldInv(double row, double column, double angleStart, double angleEnd, double radiusStart, double radiusEnd, int widthIn, int heightIn, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(1);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.StoreD(proc, 4, radiusStart);
			HalconAPI.StoreD(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, widthIn);
			HalconAPI.StoreI(proc, 7, heightIn);
			HalconAPI.StoreI(proc, 8, width);
			HalconAPI.StoreI(proc, 9, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a contour in an annular arc to polar coordinates.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to be mapped to the column coordinate 0 of PolarTransContour. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to be mapped to the column coordinate $Width-1$ of PolarTransContour to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to be mapped to the row coordinate 0 of PolarTransContour. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to be mapped to the row coordinate $Height-1$ of PolarTransContour. Default: 100</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <returns>Output contour.</returns>
		// Token: 0x06001BEC RID: 7148 RVA: 0x000AC290 File Offset: 0x000AA490
		public HXLDCont PolarTransContourXld(HTuple row, HTuple column, double angleStart, double angleEnd, HTuple radiusStart, HTuple radiusEnd, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(2);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.Store(proc, 4, radiusStart);
			HalconAPI.Store(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radiusStart);
			HalconAPI.UnpinTuple(radiusEnd);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a contour in an annular arc to polar coordinates.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the arc. Default: 256</param>
		/// <param name="column">Column coordinate of the center of the arc. Default: 256</param>
		/// <param name="angleStart">Angle of the ray to be mapped to the column coordinate 0 of PolarTransContour. Default: 0.0</param>
		/// <param name="angleEnd">Angle of the ray to be mapped to the column coordinate $Width-1$ of PolarTransContour to. Default: 6.2831853</param>
		/// <param name="radiusStart">Radius of the circle to be mapped to the row coordinate 0 of PolarTransContour. Default: 0</param>
		/// <param name="radiusEnd">Radius of the circle to be mapped to the row coordinate $Height-1$ of PolarTransContour. Default: 100</param>
		/// <param name="width">Width of the virtual output image. Default: 512</param>
		/// <param name="height">Height of the virtual output image. Default: 512</param>
		/// <returns>Output contour.</returns>
		// Token: 0x06001BED RID: 7149 RVA: 0x000AC334 File Offset: 0x000AA534
		public HXLDCont PolarTransContourXld(double row, double column, double angleStart, double angleEnd, double radiusStart, double radiusEnd, int width, int height)
		{
			IntPtr proc = HalconAPI.PreCall(2);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, angleStart);
			HalconAPI.StoreD(proc, 3, angleEnd);
			HalconAPI.StoreD(proc, 4, radiusStart);
			HalconAPI.StoreD(proc, 5, radiusEnd);
			HalconAPI.StoreI(proc, 6, width);
			HalconAPI.StoreI(proc, 7, height);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform a NURBS curve into an XLD contour.
		///   Modified instance represents: The contour that approximates the NURBS curve.
		/// </summary>
		/// <param name="rows">Row coordinates of the control polygon.</param>
		/// <param name="cols">Column coordinates of the control polygon.</param>
		/// <param name="knots">The knot vector $u$. Default: "auto"</param>
		/// <param name="weights">The weight vector $w$. Default: "auto"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Default: 3</param>
		/// <param name="maxError">Maximum distance between the NURBS curve and its approximation. Default: 1.0</param>
		/// <param name="maxDistance">Maximum distance between two subsequent Contour points. Default: 5.0</param>
		// Token: 0x06001BEE RID: 7150 RVA: 0x000AC3C0 File Offset: 0x000AA5C0
		public void GenContourNurbsXld(HTuple rows, HTuple cols, HTuple knots, HTuple weights, int degree, HTuple maxError, HTuple maxDistance)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(4);
			HalconAPI.Store(proc, 0, rows);
			HalconAPI.Store(proc, 1, cols);
			HalconAPI.Store(proc, 2, knots);
			HalconAPI.Store(proc, 3, weights);
			HalconAPI.StoreI(proc, 4, degree);
			HalconAPI.Store(proc, 5, maxError);
			HalconAPI.Store(proc, 6, maxDistance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows);
			HalconAPI.UnpinTuple(cols);
			HalconAPI.UnpinTuple(knots);
			HalconAPI.UnpinTuple(weights);
			HalconAPI.UnpinTuple(maxError);
			HalconAPI.UnpinTuple(maxDistance);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Transform a NURBS curve into an XLD contour.
		///   Modified instance represents: The contour that approximates the NURBS curve.
		/// </summary>
		/// <param name="rows">Row coordinates of the control polygon.</param>
		/// <param name="cols">Column coordinates of the control polygon.</param>
		/// <param name="knots">The knot vector $u$. Default: "auto"</param>
		/// <param name="weights">The weight vector $w$. Default: "auto"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Default: 3</param>
		/// <param name="maxError">Maximum distance between the NURBS curve and its approximation. Default: 1.0</param>
		/// <param name="maxDistance">Maximum distance between two subsequent Contour points. Default: 5.0</param>
		// Token: 0x06001BEF RID: 7151 RVA: 0x000AC464 File Offset: 0x000AA664
		public void GenContourNurbsXld(HTuple rows, HTuple cols, string knots, string weights, int degree, double maxError, double maxDistance)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(4);
			HalconAPI.Store(proc, 0, rows);
			HalconAPI.Store(proc, 1, cols);
			HalconAPI.StoreS(proc, 2, knots);
			HalconAPI.StoreS(proc, 3, weights);
			HalconAPI.StoreI(proc, 4, degree);
			HalconAPI.StoreD(proc, 5, maxError);
			HalconAPI.StoreD(proc, 6, maxDistance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rows);
			HalconAPI.UnpinTuple(cols);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the union of closed contours.
		///   Instance represents: Contours enclosing the first region.
		/// </summary>
		/// <param name="contours2">Contours enclosing the second region.</param>
		/// <returns>Contours enclosing the union.</returns>
		// Token: 0x06001BF0 RID: 7152 RVA: 0x000AC4EC File Offset: 0x000AA6EC
		public HXLDCont Union2ClosedContoursXld(HXLDCont contours2)
		{
			IntPtr proc = HalconAPI.PreCall(6);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contours2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours2);
			return result;
		}

		/// <summary>
		///   Compute the symmetric difference of closed contours.
		///   Instance represents: Contours enclosing the first region.
		/// </summary>
		/// <param name="contours2">Contours enclosing the second region.</param>
		/// <returns>Contours enclosing the symmetric difference.</returns>
		// Token: 0x06001BF1 RID: 7153 RVA: 0x000AC540 File Offset: 0x000AA740
		public HXLDCont SymmDifferenceClosedContoursXld(HXLDCont contours2)
		{
			IntPtr proc = HalconAPI.PreCall(8);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contours2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours2);
			return result;
		}

		/// <summary>
		///   Compute the difference of closed contours.
		///   Instance represents: Contours enclosing the region from which the second region is subtracted.
		/// </summary>
		/// <param name="sub">Contours enclosing the region that is subtracted from the first region.</param>
		/// <returns>Contours enclosing the difference.</returns>
		// Token: 0x06001BF2 RID: 7154 RVA: 0x000AC594 File Offset: 0x000AA794
		public HXLDCont DifferenceClosedContoursXld(HXLDCont sub)
		{
			IntPtr proc = HalconAPI.PreCall(10);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, sub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(sub);
			return result;
		}

		/// <summary>
		///   Intersect closed contours.
		///   Instance represents: Contours enclosing the first region to be intersected.
		/// </summary>
		/// <param name="contours2">Contours enclosing the second region to be intersected.</param>
		/// <returns>Contours enclosing the intersection.</returns>
		// Token: 0x06001BF3 RID: 7155 RVA: 0x000AC5E8 File Offset: 0x000AA7E8
		public HXLDCont IntersectionClosedContoursXld(HXLDCont contours2)
		{
			IntPtr proc = HalconAPI.PreCall(12);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contours2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours2);
			return result;
		}

		/// <summary>
		///   Compute the union of contours that belong to the same circle.
		///   Instance represents: Contours to be merged.
		/// </summary>
		/// <param name="maxArcAngleDiff">Maximum angular distance of two circular arcs. Default: 0.5</param>
		/// <param name="maxArcOverlap">Maximum overlap of two circular arcs. Default: 0.1</param>
		/// <param name="maxTangentAngle">Maximum angle between the connecting line and the tangents of circular arcs. Default: 0.2</param>
		/// <param name="maxDist">Maximum length of the gap between two circular arcs in pixels. Default: 30</param>
		/// <param name="maxRadiusDiff">Maximum radius difference of the circles fitted to two arcs. Default: 10</param>
		/// <param name="maxCenterDist">Maximum center distance of the circles fitted to two arcs. Default: 10</param>
		/// <param name="mergeSmallContours">Determine whether small contours without fitted circles should also be merged. Default: "true"</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Merged contours.</returns>
		// Token: 0x06001BF4 RID: 7156 RVA: 0x000AC63C File Offset: 0x000AA83C
		public HXLDCont UnionCocircularContoursXld(HTuple maxArcAngleDiff, HTuple maxArcOverlap, HTuple maxTangentAngle, HTuple maxDist, HTuple maxRadiusDiff, HTuple maxCenterDist, string mergeSmallContours, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(13);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, maxArcAngleDiff);
			HalconAPI.Store(proc, 1, maxArcOverlap);
			HalconAPI.Store(proc, 2, maxTangentAngle);
			HalconAPI.Store(proc, 3, maxDist);
			HalconAPI.Store(proc, 4, maxRadiusDiff);
			HalconAPI.Store(proc, 5, maxCenterDist);
			HalconAPI.StoreS(proc, 6, mergeSmallContours);
			HalconAPI.StoreI(proc, 7, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(maxArcAngleDiff);
			HalconAPI.UnpinTuple(maxArcOverlap);
			HalconAPI.UnpinTuple(maxTangentAngle);
			HalconAPI.UnpinTuple(maxDist);
			HalconAPI.UnpinTuple(maxRadiusDiff);
			HalconAPI.UnpinTuple(maxCenterDist);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the union of contours that belong to the same circle.
		///   Instance represents: Contours to be merged.
		/// </summary>
		/// <param name="maxArcAngleDiff">Maximum angular distance of two circular arcs. Default: 0.5</param>
		/// <param name="maxArcOverlap">Maximum overlap of two circular arcs. Default: 0.1</param>
		/// <param name="maxTangentAngle">Maximum angle between the connecting line and the tangents of circular arcs. Default: 0.2</param>
		/// <param name="maxDist">Maximum length of the gap between two circular arcs in pixels. Default: 30</param>
		/// <param name="maxRadiusDiff">Maximum radius difference of the circles fitted to two arcs. Default: 10</param>
		/// <param name="maxCenterDist">Maximum center distance of the circles fitted to two arcs. Default: 10</param>
		/// <param name="mergeSmallContours">Determine whether small contours without fitted circles should also be merged. Default: "true"</param>
		/// <param name="iterations">Number of iterations. Default: 1</param>
		/// <returns>Merged contours.</returns>
		// Token: 0x06001BF5 RID: 7157 RVA: 0x000AC6F0 File Offset: 0x000AA8F0
		public HXLDCont UnionCocircularContoursXld(double maxArcAngleDiff, double maxArcOverlap, double maxTangentAngle, double maxDist, double maxRadiusDiff, double maxCenterDist, string mergeSmallContours, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(13);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maxArcAngleDiff);
			HalconAPI.StoreD(proc, 1, maxArcOverlap);
			HalconAPI.StoreD(proc, 2, maxTangentAngle);
			HalconAPI.StoreD(proc, 3, maxDist);
			HalconAPI.StoreD(proc, 4, maxRadiusDiff);
			HalconAPI.StoreD(proc, 5, maxCenterDist);
			HalconAPI.StoreS(proc, 6, mergeSmallContours);
			HalconAPI.StoreI(proc, 7, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Crop an XLD contour.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="row1">Upper border of the cropping rectangle. Default: 0</param>
		/// <param name="col1">Left border of the cropping rectangle. Default: 0</param>
		/// <param name="row2">Lower border of the cropping rectangle. Default: 512</param>
		/// <param name="col2">Right border of the cropping rectangle. Default: 512</param>
		/// <param name="closeContours">Should closed contours produce closed output contours? Default: "true"</param>
		/// <returns>Output contours.</returns>
		// Token: 0x06001BF6 RID: 7158 RVA: 0x000AC77C File Offset: 0x000AA97C
		public HXLDCont CropContoursXld(HTuple row1, HTuple col1, HTuple row2, HTuple col2, string closeContours)
		{
			IntPtr proc = HalconAPI.PreCall(14);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, col1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, col2);
			HalconAPI.StoreS(proc, 4, closeContours);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(col1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(col2);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Crop an XLD contour.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="row1">Upper border of the cropping rectangle. Default: 0</param>
		/// <param name="col1">Left border of the cropping rectangle. Default: 0</param>
		/// <param name="row2">Lower border of the cropping rectangle. Default: 512</param>
		/// <param name="col2">Right border of the cropping rectangle. Default: 512</param>
		/// <param name="closeContours">Should closed contours produce closed output contours? Default: "true"</param>
		/// <returns>Output contours.</returns>
		// Token: 0x06001BF7 RID: 7159 RVA: 0x000AC804 File Offset: 0x000AAA04
		public HXLDCont CropContoursXld(double row1, double col1, double row2, double col2, string closeContours)
		{
			IntPtr proc = HalconAPI.PreCall(14);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, col1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, col2);
			HalconAPI.StoreS(proc, 4, closeContours);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Generate one XLD contour in the shape of a cross for each input point.
		///   Modified instance represents: Generated XLD contours.
		/// </summary>
		/// <param name="row">Row coordinates of the input points.</param>
		/// <param name="col">Column coordinates of the input points.</param>
		/// <param name="size">Length of the cross bars. Default: 6.0</param>
		/// <param name="angle">Orientation of the crosses. Default: 0.785398</param>
		// Token: 0x06001BF8 RID: 7160 RVA: 0x000AC874 File Offset: 0x000AAA74
		public void GenCrossContourXld(HTuple row, HTuple col, HTuple size, double angle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(15);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, col);
			HalconAPI.Store(proc, 2, size);
			HalconAPI.StoreD(proc, 3, angle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(col);
			HalconAPI.UnpinTuple(size);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate one XLD contour in the shape of a cross for each input point.
		///   Modified instance represents: Generated XLD contours.
		/// </summary>
		/// <param name="row">Row coordinates of the input points.</param>
		/// <param name="col">Column coordinates of the input points.</param>
		/// <param name="size">Length of the cross bars. Default: 6.0</param>
		/// <param name="angle">Orientation of the crosses. Default: 0.785398</param>
		// Token: 0x06001BF9 RID: 7161 RVA: 0x000AC8E8 File Offset: 0x000AAAE8
		public void GenCrossContourXld(double row, double col, double size, double angle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(15);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, col);
			HalconAPI.StoreD(proc, 2, size);
			HalconAPI.StoreD(proc, 3, angle);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Sort contours with respect to their relative position.
		///   Instance represents: Contours to be sorted.
		/// </summary>
		/// <param name="sortMode">Kind of sorting. Default: "upper_left"</param>
		/// <param name="order">Increasing or decreasing sorting order. Default: "true"</param>
		/// <param name="rowOrCol">Sorting first with respect to row, then to column. Default: "row"</param>
		/// <returns>Sorted contours.</returns>
		// Token: 0x06001BFA RID: 7162 RVA: 0x000AC94C File Offset: 0x000AAB4C
		public HXLDCont SortContoursXld(string sortMode, string order, string rowOrCol)
		{
			IntPtr proc = HalconAPI.PreCall(16);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, sortMode);
			HalconAPI.StoreS(proc, 1, order);
			HalconAPI.StoreS(proc, 2, rowOrCol);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Merge XLD contours from successive line scan images.
		///   Instance represents: Current input contours.
		/// </summary>
		/// <param name="prevConts">Merged contours from the previous iteration.</param>
		/// <param name="prevMergedConts">Contours from the previous iteration which could not be merged with the current ones.</param>
		/// <param name="imageHeight">Height of the line scan images. Default: 512</param>
		/// <param name="margin">Maximum distance of contours from the image border. Default: 0.0</param>
		/// <param name="mergeBorder">Image line of the current image, which touches the previous image. Default: "top"</param>
		/// <param name="maxImagesCont">Maximum number of images covered by one contour. Default: 3</param>
		/// <returns>Current contours, merged with old ones where applicable.</returns>
		// Token: 0x06001BFB RID: 7163 RVA: 0x000AC9AC File Offset: 0x000AABAC
		public HXLDCont MergeContLineScanXld(HXLDCont prevConts, out HXLDCont prevMergedConts, int imageHeight, HTuple margin, string mergeBorder, int maxImagesCont)
		{
			IntPtr proc = HalconAPI.PreCall(17);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, prevConts);
			HalconAPI.StoreI(proc, 0, imageHeight);
			HalconAPI.Store(proc, 1, margin);
			HalconAPI.StoreS(proc, 2, mergeBorder);
			HalconAPI.StoreI(proc, 3, maxImagesCont);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(margin);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 2, num, out prevMergedConts);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(prevConts);
			return result;
		}

		/// <summary>
		///   Merge XLD contours from successive line scan images.
		///   Instance represents: Current input contours.
		/// </summary>
		/// <param name="prevConts">Merged contours from the previous iteration.</param>
		/// <param name="prevMergedConts">Contours from the previous iteration which could not be merged with the current ones.</param>
		/// <param name="imageHeight">Height of the line scan images. Default: 512</param>
		/// <param name="margin">Maximum distance of contours from the image border. Default: 0.0</param>
		/// <param name="mergeBorder">Image line of the current image, which touches the previous image. Default: "top"</param>
		/// <param name="maxImagesCont">Maximum number of images covered by one contour. Default: 3</param>
		/// <returns>Current contours, merged with old ones where applicable.</returns>
		// Token: 0x06001BFC RID: 7164 RVA: 0x000ACA3C File Offset: 0x000AAC3C
		public HXLDCont MergeContLineScanXld(HXLDCont prevConts, out HXLDCont prevMergedConts, int imageHeight, double margin, string mergeBorder, int maxImagesCont)
		{
			IntPtr proc = HalconAPI.PreCall(17);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, prevConts);
			HalconAPI.StoreI(proc, 0, imageHeight);
			HalconAPI.StoreD(proc, 1, margin);
			HalconAPI.StoreS(proc, 2, mergeBorder);
			HalconAPI.StoreI(proc, 3, maxImagesCont);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 2, num, out prevMergedConts);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(prevConts);
			return result;
		}

		/// <summary>
		///   Read XLD contours to a file in ARC/INFO generate format.
		///   Modified instance represents: Read XLD contours.
		/// </summary>
		/// <param name="fileName">Name of the ARC/INFO file.</param>
		// Token: 0x06001BFD RID: 7165 RVA: 0x000ACAC4 File Offset: 0x000AACC4
		public void ReadContourXldArcInfo(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(20);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write XLD contours to a file in ARC/INFO generate format.
		///   Instance represents: XLD contours to be written.
		/// </summary>
		/// <param name="fileName">Name of the ARC/INFO file.</param>
		// Token: 0x06001BFE RID: 7166 RVA: 0x000ACB10 File Offset: 0x000AAD10
		public void WriteContourXldArcInfo(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(21);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the parallel contour of an XLD contour.
		///   Instance represents: Contours to be transformed.
		/// </summary>
		/// <param name="mode">Mode, with which the direction information is computed. Default: "regression_normal"</param>
		/// <param name="distance">Distance of the parallel contour. Default: 1</param>
		/// <returns>Parallel contours.</returns>
		// Token: 0x06001BFF RID: 7167 RVA: 0x000ACB4C File Offset: 0x000AAD4C
		public HXLDCont GenParallelContourXld(string mode, HTuple distance)
		{
			IntPtr proc = HalconAPI.PreCall(23);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.Store(proc, 1, distance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(distance);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the parallel contour of an XLD contour.
		///   Instance represents: Contours to be transformed.
		/// </summary>
		/// <param name="mode">Mode, with which the direction information is computed. Default: "regression_normal"</param>
		/// <param name="distance">Distance of the parallel contour. Default: 1</param>
		/// <returns>Parallel contours.</returns>
		// Token: 0x06001C00 RID: 7168 RVA: 0x000ACBA8 File Offset: 0x000AADA8
		public HXLDCont GenParallelContourXld(string mode, double distance)
		{
			IntPtr proc = HalconAPI.PreCall(23);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreD(proc, 1, distance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Create an XLD contour in the shape of a rectangle.
		///   Modified instance represents: Rectangle contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the rectangle. Default: 300.0</param>
		/// <param name="column">Column coordinate of the center of the rectangle. Default: 200.0</param>
		/// <param name="phi">Orientation of the main axis of the rectangle [rad]. Default: 0.0</param>
		/// <param name="length1">First radius (half length) of the rectangle. Default: 100.5</param>
		/// <param name="length2">Second radius (half width) of the rectangle. Default: 20.5</param>
		// Token: 0x06001C01 RID: 7169 RVA: 0x000ACC00 File Offset: 0x000AAE00
		public void GenRectangle2ContourXld(HTuple row, HTuple column, HTuple phi, HTuple length1, HTuple length2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(24);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, phi);
			HalconAPI.Store(proc, 3, length1);
			HalconAPI.Store(proc, 4, length2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(length1);
			HalconAPI.UnpinTuple(length2);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an XLD contour in the shape of a rectangle.
		///   Modified instance represents: Rectangle contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the rectangle. Default: 300.0</param>
		/// <param name="column">Column coordinate of the center of the rectangle. Default: 200.0</param>
		/// <param name="phi">Orientation of the main axis of the rectangle [rad]. Default: 0.0</param>
		/// <param name="length1">First radius (half length) of the rectangle. Default: 100.5</param>
		/// <param name="length2">Second radius (half width) of the rectangle. Default: 20.5</param>
		// Token: 0x06001C02 RID: 7170 RVA: 0x000ACC8C File Offset: 0x000AAE8C
		public void GenRectangle2ContourXld(double row, double column, double phi, double length1, double length2)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(24);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, phi);
			HalconAPI.StoreD(proc, 3, length1);
			HalconAPI.StoreD(proc, 4, length2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the distances of all contour points to a rectangle.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="clippingEndPoints">Number of points at the beginning and the end of the contours to be ignored for the computation of distances. Default: 0</param>
		/// <param name="row">Row coordinate of the center of the rectangle.</param>
		/// <param name="column">Column coordinate of the center of the rectangle.</param>
		/// <param name="phi">Orientation of the main axis of the rectangle [rad].</param>
		/// <param name="length1">First radius (half length) of the rectangle.</param>
		/// <param name="length2">Second radius (half width) of the rectangle.</param>
		/// <returns>Distances of the contour points to the rectangle.</returns>
		// Token: 0x06001C03 RID: 7171 RVA: 0x000ACCF8 File Offset: 0x000AAEF8
		public HTuple DistRectangle2ContourPointsXld(int clippingEndPoints, double row, double column, double phi, double length1, double length2)
		{
			IntPtr proc = HalconAPI.PreCall(25);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, clippingEndPoints);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			HalconAPI.StoreD(proc, 3, phi);
			HalconAPI.StoreD(proc, 4, length1);
			HalconAPI.StoreD(proc, 5, length2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Fit rectangles to XLD contours.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for fitting the rectangles. Default: "regression"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="maxClosureDist">Maximum distance between the end points of a contour to be considered as closed. Default: 0.0</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="iterations">Maximum number of iterations (not used for 'regression'). Default: 3</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for 'huber' and 2.0 for 'tukey'). Default: 2.0</param>
		/// <param name="row">Row coordinate of the center of the rectangle.</param>
		/// <param name="column">Column coordinate of the center of the rectangle.</param>
		/// <param name="phi">Orientation of the main axis of the rectangle [rad].</param>
		/// <param name="length1">First radius (half length) of the rectangle.</param>
		/// <param name="length2">Second radius (half width) of the rectangle.</param>
		/// <param name="pointOrder">Point order of the contour.</param>
		// Token: 0x06001C04 RID: 7172 RVA: 0x000ACD74 File Offset: 0x000AAF74
		public void FitRectangle2ContourXld(string algorithm, int maxNumPoints, double maxClosureDist, int clippingEndPoints, int iterations, double clippingFactor, out HTuple row, out HTuple column, out HTuple phi, out HTuple length1, out HTuple length2, out HTuple pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(26);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreD(proc, 2, maxClosureDist);
			HalconAPI.StoreI(proc, 3, clippingEndPoints);
			HalconAPI.StoreI(proc, 4, iterations);
			HalconAPI.StoreD(proc, 5, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out length1);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out length2);
			num = HTuple.LoadNew(proc, 5, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Fit rectangles to XLD contours.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for fitting the rectangles. Default: "regression"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="maxClosureDist">Maximum distance between the end points of a contour to be considered as closed. Default: 0.0</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="iterations">Maximum number of iterations (not used for 'regression'). Default: 3</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for 'huber' and 2.0 for 'tukey'). Default: 2.0</param>
		/// <param name="row">Row coordinate of the center of the rectangle.</param>
		/// <param name="column">Column coordinate of the center of the rectangle.</param>
		/// <param name="phi">Orientation of the main axis of the rectangle [rad].</param>
		/// <param name="length1">First radius (half length) of the rectangle.</param>
		/// <param name="length2">Second radius (half width) of the rectangle.</param>
		/// <param name="pointOrder">Point order of the contour.</param>
		// Token: 0x06001C05 RID: 7173 RVA: 0x000ACE50 File Offset: 0x000AB050
		public void FitRectangle2ContourXld(string algorithm, int maxNumPoints, double maxClosureDist, int clippingEndPoints, int iterations, double clippingFactor, out double row, out double column, out double phi, out double length1, out double length2, out string pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(26);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreD(proc, 2, maxClosureDist);
			HalconAPI.StoreI(proc, 3, clippingEndPoints);
			HalconAPI.StoreI(proc, 4, iterations);
			HalconAPI.StoreD(proc, 5, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out length1);
			num = HalconAPI.LoadD(proc, 4, num, out length2);
			num = HalconAPI.LoadS(proc, 5, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Segment XLD contour parts whose local attributes fulfill given  conditions.
		///   Instance represents: Contour to be segmented.
		/// </summary>
		/// <param name="attribute">Contour attributes to be checked. Default: "distance"</param>
		/// <param name="operation">Linkage type of the individual attributes. Default: "and"</param>
		/// <param name="min">Lower limits of the attribute values. Default: 150.0</param>
		/// <param name="max">Upper limits of the attribute values. Default: 99999.0</param>
		/// <returns>Segmented contour parts.</returns>
		// Token: 0x06001C06 RID: 7174 RVA: 0x000ACF28 File Offset: 0x000AB128
		public HXLDCont SegmentContourAttribXld(HTuple attribute, string operation, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(27);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, attribute);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.Store(proc, 2, min);
			HalconAPI.Store(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(attribute);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment XLD contour parts whose local attributes fulfill given  conditions.
		///   Instance represents: Contour to be segmented.
		/// </summary>
		/// <param name="attribute">Contour attributes to be checked. Default: "distance"</param>
		/// <param name="operation">Linkage type of the individual attributes. Default: "and"</param>
		/// <param name="min">Lower limits of the attribute values. Default: 150.0</param>
		/// <param name="max">Upper limits of the attribute values. Default: 99999.0</param>
		/// <returns>Segmented contour parts.</returns>
		// Token: 0x06001C07 RID: 7175 RVA: 0x000ACFA4 File Offset: 0x000AB1A4
		public HXLDCont SegmentContourAttribXld(string attribute, string operation, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(27);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, attribute);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.StoreD(proc, 2, min);
			HalconAPI.StoreD(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Segment XLD contours into line segments and circular or elliptic arcs.
		///   Instance represents: Contours to be segmented.
		/// </summary>
		/// <param name="mode">Mode for the segmentation of the contours. Default: "lines_circles"</param>
		/// <param name="smoothCont">Number of points used for smoothing the contours. Default: 5</param>
		/// <param name="maxLineDist1">Maximum distance between a contour and the approximating line (first iteration). Default: 4.0</param>
		/// <param name="maxLineDist2">Maximum distance between a contour and the approximating line (second iteration). Default: 2.0</param>
		/// <returns>Segmented contours.</returns>
		// Token: 0x06001C08 RID: 7176 RVA: 0x000AD00C File Offset: 0x000AB20C
		public HXLDCont SegmentContoursXld(string mode, int smoothCont, double maxLineDist1, double maxLineDist2)
		{
			IntPtr proc = HalconAPI.PreCall(28);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, smoothCont);
			HalconAPI.StoreD(proc, 2, maxLineDist1);
			HalconAPI.StoreD(proc, 3, maxLineDist2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Approximate XLD contours by circles.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for the fitting of circles. Default: "algebraic"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="maxClosureDist">Maximum distance between the end points of a contour to be considered as 'closed'. Default: 0.0</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="iterations">Maximum number of iterations for the robust weighted fitting. Default: 3</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for Huber and 2.0 for Tukey). Default: 2.0</param>
		/// <param name="row">Row coordinate of the center of the circle.</param>
		/// <param name="column">Column coordinate of the center of the circle.</param>
		/// <param name="radius">Radius of circle.</param>
		/// <param name="startPhi">Angle of the start point [rad].</param>
		/// <param name="endPhi">Angle of the end point [rad].</param>
		/// <param name="pointOrder">Point order along the boundary.</param>
		// Token: 0x06001C09 RID: 7177 RVA: 0x000AD074 File Offset: 0x000AB274
		public void FitCircleContourXld(string algorithm, int maxNumPoints, double maxClosureDist, int clippingEndPoints, int iterations, double clippingFactor, out HTuple row, out HTuple column, out HTuple radius, out HTuple startPhi, out HTuple endPhi, out HTuple pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(29);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreD(proc, 2, maxClosureDist);
			HalconAPI.StoreI(proc, 3, clippingEndPoints);
			HalconAPI.StoreI(proc, 4, iterations);
			HalconAPI.StoreD(proc, 5, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out radius);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out startPhi);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out endPhi);
			num = HTuple.LoadNew(proc, 5, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate XLD contours by circles.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for the fitting of circles. Default: "algebraic"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="maxClosureDist">Maximum distance between the end points of a contour to be considered as 'closed'. Default: 0.0</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="iterations">Maximum number of iterations for the robust weighted fitting. Default: 3</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for Huber and 2.0 for Tukey). Default: 2.0</param>
		/// <param name="row">Row coordinate of the center of the circle.</param>
		/// <param name="column">Column coordinate of the center of the circle.</param>
		/// <param name="radius">Radius of circle.</param>
		/// <param name="startPhi">Angle of the start point [rad].</param>
		/// <param name="endPhi">Angle of the end point [rad].</param>
		/// <param name="pointOrder">Point order along the boundary.</param>
		// Token: 0x06001C0A RID: 7178 RVA: 0x000AD150 File Offset: 0x000AB350
		public void FitCircleContourXld(string algorithm, int maxNumPoints, double maxClosureDist, int clippingEndPoints, int iterations, double clippingFactor, out double row, out double column, out double radius, out double startPhi, out double endPhi, out string pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(29);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreD(proc, 2, maxClosureDist);
			HalconAPI.StoreI(proc, 3, clippingEndPoints);
			HalconAPI.StoreI(proc, 4, iterations);
			HalconAPI.StoreD(proc, 5, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out radius);
			num = HalconAPI.LoadD(proc, 3, num, out startPhi);
			num = HalconAPI.LoadD(proc, 4, num, out endPhi);
			num = HalconAPI.LoadS(proc, 5, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate XLD contours by line segments.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for the fitting of lines. Default: "tukey"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for 'huber' and 'drop' and 2.0 for  'tukey'). Default: 2.0</param>
		/// <param name="rowBegin">Row coordinates of the starting points of the line segments.</param>
		/// <param name="colBegin">Column coordinates of the starting points of the line segments.</param>
		/// <param name="rowEnd">Row coordinates of the end points of the line segments.</param>
		/// <param name="colEnd">Column coordinates of the end points of the line segments.</param>
		/// <param name="nr">Line parameter: Row coordinate of the normal vector</param>
		/// <param name="nc">Line parameter: Column coordinate of the normal vector</param>
		/// <param name="dist">Line parameter: Distance of the line from the origin</param>
		// Token: 0x06001C0B RID: 7179 RVA: 0x000AD228 File Offset: 0x000AB428
		public void FitLineContourXld(string algorithm, int maxNumPoints, int clippingEndPoints, int iterations, double clippingFactor, out HTuple rowBegin, out HTuple colBegin, out HTuple rowEnd, out HTuple colEnd, out HTuple nr, out HTuple nc, out HTuple dist)
		{
			IntPtr proc = HalconAPI.PreCall(30);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreI(proc, 2, clippingEndPoints);
			HalconAPI.StoreI(proc, 3, iterations);
			HalconAPI.StoreD(proc, 4, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rowBegin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out colBegin);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out rowEnd);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out colEnd);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out nr);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out nc);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out dist);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate XLD contours by line segments.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for the fitting of lines. Default: "tukey"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="iterations">Maximum number of iterations (unused for 'regression'). Default: 5</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for 'huber' and 'drop' and 2.0 for  'tukey'). Default: 2.0</param>
		/// <param name="rowBegin">Row coordinates of the starting points of the line segments.</param>
		/// <param name="colBegin">Column coordinates of the starting points of the line segments.</param>
		/// <param name="rowEnd">Row coordinates of the end points of the line segments.</param>
		/// <param name="colEnd">Column coordinates of the end points of the line segments.</param>
		/// <param name="nr">Line parameter: Row coordinate of the normal vector</param>
		/// <param name="nc">Line parameter: Column coordinate of the normal vector</param>
		/// <param name="dist">Line parameter: Distance of the line from the origin</param>
		// Token: 0x06001C0C RID: 7180 RVA: 0x000AD310 File Offset: 0x000AB510
		public void FitLineContourXld(string algorithm, int maxNumPoints, int clippingEndPoints, int iterations, double clippingFactor, out double rowBegin, out double colBegin, out double rowEnd, out double colEnd, out double nr, out double nc, out double dist)
		{
			IntPtr proc = HalconAPI.PreCall(30);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreI(proc, 2, clippingEndPoints);
			HalconAPI.StoreI(proc, 3, iterations);
			HalconAPI.StoreD(proc, 4, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out rowBegin);
			num = HalconAPI.LoadD(proc, 1, num, out colBegin);
			num = HalconAPI.LoadD(proc, 2, num, out rowEnd);
			num = HalconAPI.LoadD(proc, 3, num, out colEnd);
			num = HalconAPI.LoadD(proc, 4, num, out nr);
			num = HalconAPI.LoadD(proc, 5, num, out nc);
			num = HalconAPI.LoadD(proc, 6, num, out dist);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the distances of all contour points to an ellipse.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="distanceMode">Mode for unsigned or signed distance values. Default: "unsigned"</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and the end of the contours to be ignored for the computation of distances. Default: 0</param>
		/// <param name="row">Row coordinate of the center of the ellipse.</param>
		/// <param name="column">Column coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis in radian.</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <returns>Distances of the contour points to the ellipse.</returns>
		// Token: 0x06001C0D RID: 7181 RVA: 0x000AD3F0 File Offset: 0x000AB5F0
		public HTuple DistEllipseContourPointsXld(string distanceMode, int clippingEndPoints, double row, double column, double phi, double radius1, double radius2)
		{
			IntPtr proc = HalconAPI.PreCall(31);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, distanceMode);
			HalconAPI.StoreI(proc, 1, clippingEndPoints);
			HalconAPI.StoreD(proc, 2, row);
			HalconAPI.StoreD(proc, 3, column);
			HalconAPI.StoreD(proc, 4, phi);
			HalconAPI.StoreD(proc, 5, radius1);
			HalconAPI.StoreD(proc, 6, radius2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the distance of contours to an ellipse.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="mode">Method for the determination of the distances. Default: "geometric"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and the end of the contours to be ignored for the computation of distances. Default: 0</param>
		/// <param name="row">Row coordinate of the center of the ellipse.</param>
		/// <param name="column">Column coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis in radian.</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="minDist">Minimum distance.</param>
		/// <param name="maxDist">Maximum distance.</param>
		/// <param name="avgDist">Mean distance.</param>
		/// <param name="sigmaDist">Standard deviation of the distance.</param>
		// Token: 0x06001C0E RID: 7182 RVA: 0x000AD474 File Offset: 0x000AB674
		public void DistEllipseContourXld(string mode, int maxNumPoints, int clippingEndPoints, double row, double column, double phi, double radius1, double radius2, out HTuple minDist, out HTuple maxDist, out HTuple avgDist, out HTuple sigmaDist)
		{
			IntPtr proc = HalconAPI.PreCall(32);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreI(proc, 2, clippingEndPoints);
			HalconAPI.StoreD(proc, 3, row);
			HalconAPI.StoreD(proc, 4, column);
			HalconAPI.StoreD(proc, 5, phi);
			HalconAPI.StoreD(proc, 6, radius1);
			HalconAPI.StoreD(proc, 7, radius2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out minDist);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out maxDist);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out avgDist);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out sigmaDist);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the distance of contours to an ellipse.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="mode">Method for the determination of the distances. Default: "geometric"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and the end of the contours to be ignored for the computation of distances. Default: 0</param>
		/// <param name="row">Row coordinate of the center of the ellipse.</param>
		/// <param name="column">Column coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis in radian.</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="minDist">Minimum distance.</param>
		/// <param name="maxDist">Maximum distance.</param>
		/// <param name="avgDist">Mean distance.</param>
		/// <param name="sigmaDist">Standard deviation of the distance.</param>
		// Token: 0x06001C0F RID: 7183 RVA: 0x000AD53C File Offset: 0x000AB73C
		public void DistEllipseContourXld(string mode, int maxNumPoints, int clippingEndPoints, double row, double column, double phi, double radius1, double radius2, out double minDist, out double maxDist, out double avgDist, out double sigmaDist)
		{
			IntPtr proc = HalconAPI.PreCall(32);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreI(proc, 2, clippingEndPoints);
			HalconAPI.StoreD(proc, 3, row);
			HalconAPI.StoreD(proc, 4, column);
			HalconAPI.StoreD(proc, 5, phi);
			HalconAPI.StoreD(proc, 6, radius1);
			HalconAPI.StoreD(proc, 7, radius2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out minDist);
			num = HalconAPI.LoadD(proc, 1, num, out maxDist);
			num = HalconAPI.LoadD(proc, 2, num, out avgDist);
			num = HalconAPI.LoadD(proc, 3, num, out sigmaDist);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate XLD contours by ellipses or elliptic arcs.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for the fitting of ellipses. Default: "fitzgibbon"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="maxClosureDist">Maximum distance between the end points of a contour to be considered as 'closed'. Default: 0.0</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="vossTabSize">Number of circular segments used for the Voss approach. Default: 200</param>
		/// <param name="iterations">Maximum number of iterations for the robust weighted fitting. Default: 3</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for '*huber' and 2.0 for '*tukey'). Default: 2.0</param>
		/// <param name="row">Row coordinate of the center of the ellipse.</param>
		/// <param name="column">Column coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="startPhi">Angle of the start point [rad].</param>
		/// <param name="endPhi">Angle of the end point [rad].</param>
		/// <param name="pointOrder">point order along the boundary.</param>
		// Token: 0x06001C10 RID: 7184 RVA: 0x000AD600 File Offset: 0x000AB800
		public void FitEllipseContourXld(string algorithm, int maxNumPoints, double maxClosureDist, int clippingEndPoints, int vossTabSize, int iterations, double clippingFactor, out HTuple row, out HTuple column, out HTuple phi, out HTuple radius1, out HTuple radius2, out HTuple startPhi, out HTuple endPhi, out HTuple pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(33);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreD(proc, 2, maxClosureDist);
			HalconAPI.StoreI(proc, 3, clippingEndPoints);
			HalconAPI.StoreI(proc, 4, vossTabSize);
			HalconAPI.StoreI(proc, 5, iterations);
			HalconAPI.StoreD(proc, 6, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out column);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out phi);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out radius1);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out radius2);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out startPhi);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out endPhi);
			num = HTuple.LoadNew(proc, 7, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Approximate XLD contours by ellipses or elliptic arcs.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="algorithm">Algorithm for the fitting of ellipses. Default: "fitzgibbon"</param>
		/// <param name="maxNumPoints">Maximum number of contour points used for the computation (-1 for all points). Default: -1</param>
		/// <param name="maxClosureDist">Maximum distance between the end points of a contour to be considered as 'closed'. Default: 0.0</param>
		/// <param name="clippingEndPoints">Number of points at the beginning and at the end of the contours to be ignored for the fitting. Default: 0</param>
		/// <param name="vossTabSize">Number of circular segments used for the Voss approach. Default: 200</param>
		/// <param name="iterations">Maximum number of iterations for the robust weighted fitting. Default: 3</param>
		/// <param name="clippingFactor">Clipping factor for the elimination of outliers (typical: 1.0 for '*huber' and 2.0 for '*tukey'). Default: 2.0</param>
		/// <param name="row">Row coordinate of the center of the ellipse.</param>
		/// <param name="column">Column coordinate of the center of the ellipse.</param>
		/// <param name="phi">Orientation of the main axis [rad].</param>
		/// <param name="radius1">Length of the larger half axis.</param>
		/// <param name="radius2">Length of the smaller half axis.</param>
		/// <param name="startPhi">Angle of the start point [rad].</param>
		/// <param name="endPhi">Angle of the end point [rad].</param>
		/// <param name="pointOrder">point order along the boundary.</param>
		// Token: 0x06001C11 RID: 7185 RVA: 0x000AD70C File Offset: 0x000AB90C
		public void FitEllipseContourXld(string algorithm, int maxNumPoints, double maxClosureDist, int clippingEndPoints, int vossTabSize, int iterations, double clippingFactor, out double row, out double column, out double phi, out double radius1, out double radius2, out double startPhi, out double endPhi, out string pointOrder)
		{
			IntPtr proc = HalconAPI.PreCall(33);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, algorithm);
			HalconAPI.StoreI(proc, 1, maxNumPoints);
			HalconAPI.StoreD(proc, 2, maxClosureDist);
			HalconAPI.StoreI(proc, 3, clippingEndPoints);
			HalconAPI.StoreI(proc, 4, vossTabSize);
			HalconAPI.StoreI(proc, 5, iterations);
			HalconAPI.StoreD(proc, 6, clippingFactor);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			num = HalconAPI.LoadD(proc, 2, num, out phi);
			num = HalconAPI.LoadD(proc, 3, num, out radius1);
			num = HalconAPI.LoadD(proc, 4, num, out radius2);
			num = HalconAPI.LoadD(proc, 5, num, out startPhi);
			num = HalconAPI.LoadD(proc, 6, num, out endPhi);
			num = HalconAPI.LoadS(proc, 7, num, out pointOrder);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create XLD contours corresponding to circles or circular arcs.
		///   Modified instance represents: Resulting contours.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the circles or circular arcs. Default: 200.0</param>
		/// <param name="column">Column coordinate of the center of the circles or circular arcs. Default: 200.0</param>
		/// <param name="radius">Radius of the circles or circular arcs. Default: 100.0</param>
		/// <param name="startPhi">Angle of the start points of the circles or circular arcs [rad]. Default: 0.0</param>
		/// <param name="endPhi">Angle of the end points of the circles or circular arcs [rad]. Default: 6.28318</param>
		/// <param name="pointOrder">Point order along the circles or circular arcs. Default: "positive"</param>
		/// <param name="resolution">Distance between neighboring contour points. Default: 1.0</param>
		// Token: 0x06001C12 RID: 7186 RVA: 0x000AD814 File Offset: 0x000ABA14
		public void GenCircleContourXld(HTuple row, HTuple column, HTuple radius, HTuple startPhi, HTuple endPhi, HTuple pointOrder, double resolution)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(34);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.Store(proc, 3, startPhi);
			HalconAPI.Store(proc, 4, endPhi);
			HalconAPI.Store(proc, 5, pointOrder);
			HalconAPI.StoreD(proc, 6, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(startPhi);
			HalconAPI.UnpinTuple(endPhi);
			HalconAPI.UnpinTuple(pointOrder);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create XLD contours corresponding to circles or circular arcs.
		///   Modified instance represents: Resulting contours.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the circles or circular arcs. Default: 200.0</param>
		/// <param name="column">Column coordinate of the center of the circles or circular arcs. Default: 200.0</param>
		/// <param name="radius">Radius of the circles or circular arcs. Default: 100.0</param>
		/// <param name="startPhi">Angle of the start points of the circles or circular arcs [rad]. Default: 0.0</param>
		/// <param name="endPhi">Angle of the end points of the circles or circular arcs [rad]. Default: 6.28318</param>
		/// <param name="pointOrder">Point order along the circles or circular arcs. Default: "positive"</param>
		/// <param name="resolution">Distance between neighboring contour points. Default: 1.0</param>
		// Token: 0x06001C13 RID: 7187 RVA: 0x000AD8B8 File Offset: 0x000ABAB8
		public void GenCircleContourXld(double row, double column, double radius, double startPhi, double endPhi, string pointOrder, double resolution)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(34);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, radius);
			HalconAPI.StoreD(proc, 3, startPhi);
			HalconAPI.StoreD(proc, 4, endPhi);
			HalconAPI.StoreS(proc, 5, pointOrder);
			HalconAPI.StoreD(proc, 6, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an XLD contour that corresponds to an elliptic arc.
		///   Modified instance represents: Resulting contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the ellipse. Default: 200.0</param>
		/// <param name="column">Column coordinate of the center of the ellipse. Default: 200.0</param>
		/// <param name="phi">Orientation of the main axis [rad]. Default: 0.0</param>
		/// <param name="radius1">Length of the larger half axis. Default: 100.0</param>
		/// <param name="radius2">Length of the smaller half axis. Default: 50.0</param>
		/// <param name="startPhi">Angle of the start point on the smallest surrounding circle  [rad]. Default: 0.0</param>
		/// <param name="endPhi">Angle of the end point on the smallest surrounding circle  [rad]. Default: 6.28318</param>
		/// <param name="pointOrder">point order along the boundary. Default: "positive"</param>
		/// <param name="resolution">Resolution: Maximum distance between neighboring contour points. Default: 1.5</param>
		// Token: 0x06001C14 RID: 7188 RVA: 0x000AD938 File Offset: 0x000ABB38
		public void GenEllipseContourXld(HTuple row, HTuple column, HTuple phi, HTuple radius1, HTuple radius2, HTuple startPhi, HTuple endPhi, HTuple pointOrder, double resolution)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(35);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.Store(proc, 2, phi);
			HalconAPI.Store(proc, 3, radius1);
			HalconAPI.Store(proc, 4, radius2);
			HalconAPI.Store(proc, 5, startPhi);
			HalconAPI.Store(proc, 6, endPhi);
			HalconAPI.Store(proc, 7, pointOrder);
			HalconAPI.StoreD(proc, 8, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HalconAPI.UnpinTuple(phi);
			HalconAPI.UnpinTuple(radius1);
			HalconAPI.UnpinTuple(radius2);
			HalconAPI.UnpinTuple(startPhi);
			HalconAPI.UnpinTuple(endPhi);
			HalconAPI.UnpinTuple(pointOrder);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an XLD contour that corresponds to an elliptic arc.
		///   Modified instance represents: Resulting contour.
		/// </summary>
		/// <param name="row">Row coordinate of the center of the ellipse. Default: 200.0</param>
		/// <param name="column">Column coordinate of the center of the ellipse. Default: 200.0</param>
		/// <param name="phi">Orientation of the main axis [rad]. Default: 0.0</param>
		/// <param name="radius1">Length of the larger half axis. Default: 100.0</param>
		/// <param name="radius2">Length of the smaller half axis. Default: 50.0</param>
		/// <param name="startPhi">Angle of the start point on the smallest surrounding circle  [rad]. Default: 0.0</param>
		/// <param name="endPhi">Angle of the end point on the smallest surrounding circle  [rad]. Default: 6.28318</param>
		/// <param name="pointOrder">point order along the boundary. Default: "positive"</param>
		/// <param name="resolution">Resolution: Maximum distance between neighboring contour points. Default: 1.5</param>
		// Token: 0x06001C15 RID: 7189 RVA: 0x000AD9FC File Offset: 0x000ABBFC
		public void GenEllipseContourXld(double row, double column, double phi, double radius1, double radius2, double startPhi, double endPhi, string pointOrder, double resolution)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(35);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.StoreD(proc, 2, phi);
			HalconAPI.StoreD(proc, 3, radius1);
			HalconAPI.StoreD(proc, 4, radius2);
			HalconAPI.StoreD(proc, 5, startPhi);
			HalconAPI.StoreD(proc, 6, endPhi);
			HalconAPI.StoreS(proc, 7, pointOrder);
			HalconAPI.StoreD(proc, 8, resolution);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Add noise to XLD contours.
		///   Instance represents: Original contours.
		/// </summary>
		/// <param name="numRegrPoints">Number of points used to calculate the regression line. Default: 5</param>
		/// <param name="amp">Maximum amplitude of the added noise (equally distributed in [-Amp,Amp]). Default: 1.0</param>
		/// <returns>Noisy contours.</returns>
		// Token: 0x06001C16 RID: 7190 RVA: 0x000ADA8C File Offset: 0x000ABC8C
		public HXLDCont AddNoiseWhiteContourXld(int numRegrPoints, double amp)
		{
			IntPtr proc = HalconAPI.PreCall(36);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numRegrPoints);
			HalconAPI.StoreD(proc, 1, amp);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Approximate XLD contours by polygons.
		///   Instance represents: Contours to be approximated.
		/// </summary>
		/// <param name="type">Type of approximation. Default: "ramer"</param>
		/// <param name="alpha">Threshold for the approximation. Default: 2.0</param>
		/// <returns>Approximating polygons.</returns>
		// Token: 0x06001C17 RID: 7191 RVA: 0x000ADAE4 File Offset: 0x000ABCE4
		public HXLDPoly GenPolygonsXld(string type, HTuple alpha)
		{
			IntPtr proc = HalconAPI.PreCall(45);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.Store(proc, 1, alpha);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(alpha);
			HXLDPoly result;
			num = HXLDPoly.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Approximate XLD contours by polygons.
		///   Instance represents: Contours to be approximated.
		/// </summary>
		/// <param name="type">Type of approximation. Default: "ramer"</param>
		/// <param name="alpha">Threshold for the approximation. Default: 2.0</param>
		/// <returns>Approximating polygons.</returns>
		// Token: 0x06001C18 RID: 7192 RVA: 0x000ADB40 File Offset: 0x000ABD40
		public HXLDPoly GenPolygonsXld(string type, double alpha)
		{
			IntPtr proc = HalconAPI.PreCall(45);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.StoreD(proc, 1, alpha);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDPoly result;
			num = HXLDPoly.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply a projective transformation to an XLD contour.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="homMat2D">Homogeneous projective transformation matrix.</param>
		/// <returns>Output contours.</returns>
		// Token: 0x06001C19 RID: 7193 RVA: 0x000ADB98 File Offset: 0x000ABD98
		public HXLDCont ProjectiveTransContourXld(HHomMat2D homMat2D)
		{
			IntPtr proc = HalconAPI.PreCall(47);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Apply an arbitrary affine 2D transformation to XLD contours.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="homMat2D">Input transformation matrix.</param>
		/// <returns>Transformed XLD contours.</returns>
		// Token: 0x06001C1A RID: 7194 RVA: 0x000ADBF8 File Offset: 0x000ABDF8
		public HXLDCont AffineTransContourXld(HHomMat2D homMat2D)
		{
			IntPtr proc = HalconAPI.PreCall(49);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, homMat2D);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Close an XLD contour.
		///   Instance represents: Contours to be closed.
		/// </summary>
		/// <returns>Closed contours.</returns>
		// Token: 0x06001C1B RID: 7195 RVA: 0x000ADC58 File Offset: 0x000ABE58
		public HXLDCont CloseContoursXld()
		{
			IntPtr proc = HalconAPI.PreCall(50);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Clip the end points of an XLD contour.
		///   Instance represents: Input contour
		/// </summary>
		/// <param name="mode">Clipping mode. Default: "num_points"</param>
		/// <param name="length">Clipping length in unit pixels (Mode $=$ 'length') or number (Mode $=$ 'num_points') Default: 3</param>
		/// <returns>Clipped contour</returns>
		// Token: 0x06001C1C RID: 7196 RVA: 0x000ADCA0 File Offset: 0x000ABEA0
		public HXLDCont ClipEndPointsContoursXld(string mode, HTuple length)
		{
			IntPtr proc = HalconAPI.PreCall(51);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.Store(proc, 1, length);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(length);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Clip the end points of an XLD contour.
		///   Instance represents: Input contour
		/// </summary>
		/// <param name="mode">Clipping mode. Default: "num_points"</param>
		/// <param name="length">Clipping length in unit pixels (Mode $=$ 'length') or number (Mode $=$ 'num_points') Default: 3</param>
		/// <returns>Clipped contour</returns>
		// Token: 0x06001C1D RID: 7197 RVA: 0x000ADCFC File Offset: 0x000ABEFC
		public HXLDCont ClipEndPointsContoursXld(string mode, double length)
		{
			IntPtr proc = HalconAPI.PreCall(51);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreD(proc, 1, length);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Clip an XLD contour.
		///   Instance represents: Contours to be clipped.
		/// </summary>
		/// <param name="row1">Row coordinate of the upper left corner of the clip rectangle. Default: 0</param>
		/// <param name="column1">Column coordinate of the upper left corner of the clip rectangle. Default: 0</param>
		/// <param name="row2">Row coordinate of the lower right corner of the clip rectangle. Default: 512</param>
		/// <param name="column2">Column coordinate of the lower right corner of the clip rectangle. Default: 512</param>
		/// <returns>Clipped contours.</returns>
		// Token: 0x06001C1E RID: 7198 RVA: 0x000ADD54 File Offset: 0x000ABF54
		public HXLDCont ClipContoursXld(int row1, int column1, int row2, int column2)
		{
			IntPtr proc = HalconAPI.PreCall(52);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, row1);
			HalconAPI.StoreI(proc, 1, column1);
			HalconAPI.StoreI(proc, 2, row2);
			HalconAPI.StoreI(proc, 3, column2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select XLD contours with a local maximum of gray values.
		///   Instance represents: XLD contours to be examined.
		/// </summary>
		/// <param name="image">Corresponding gray value image.</param>
		/// <param name="minPercent">Minimum percentage of maximum points. Default: 70</param>
		/// <param name="minDiff">Minimum amount by which the gray value at the maximum must be larger than in the profile. Default: 15</param>
		/// <param name="distance">Maximum width of profile used to check for maxima. Default: 4</param>
		/// <returns>Selected contours.</returns>
		// Token: 0x06001C1F RID: 7199 RVA: 0x000ADDBC File Offset: 0x000ABFBC
		public HXLDCont LocalMaxContoursXld(HImage image, HTuple minPercent, int minDiff, int distance)
		{
			IntPtr proc = HalconAPI.PreCall(53);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 0, minPercent);
			HalconAPI.StoreI(proc, 1, minDiff);
			HalconAPI.StoreI(proc, 2, distance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(minPercent);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Select XLD contours with a local maximum of gray values.
		///   Instance represents: XLD contours to be examined.
		/// </summary>
		/// <param name="image">Corresponding gray value image.</param>
		/// <param name="minPercent">Minimum percentage of maximum points. Default: 70</param>
		/// <param name="minDiff">Minimum amount by which the gray value at the maximum must be larger than in the profile. Default: 15</param>
		/// <param name="distance">Maximum width of profile used to check for maxima. Default: 4</param>
		/// <returns>Selected contours.</returns>
		// Token: 0x06001C20 RID: 7200 RVA: 0x000ADE30 File Offset: 0x000AC030
		public HXLDCont LocalMaxContoursXld(HImage image, int minPercent, int minDiff, int distance)
		{
			IntPtr proc = HalconAPI.PreCall(53);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreI(proc, 0, minPercent);
			HalconAPI.StoreI(proc, 1, minDiff);
			HalconAPI.StoreI(proc, 2, distance);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the union of neighboring straight contours that have a similar  distance from a given line.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="selectedContours">Output XLD contours.</param>
		/// <param name="refLineStartRow">y coordinate of the starting point of the reference line. Default: 0</param>
		/// <param name="refLineStartColumn">x coordinate of the starting point of the reference line. Default: 0</param>
		/// <param name="refLineEndRow">y coordinate of the endpoint of the reference line. Default: 0</param>
		/// <param name="refLineEndColumn">x coordinate of the endpoint of the reference line. Default: 0</param>
		/// <param name="width">Maximum distance. Default: 1</param>
		/// <param name="maxWidth">Maximum Width between two minimas. Default: 1</param>
		/// <param name="filterSize">Size of Smoothfilter Default: 1</param>
		/// <param name="histoValues">Output Values of Histogram.</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001C21 RID: 7201 RVA: 0x000ADE9C File Offset: 0x000AC09C
		public HXLDCont UnionStraightContoursHistoXld(out HXLDCont selectedContours, int refLineStartRow, int refLineStartColumn, int refLineEndRow, int refLineEndColumn, int width, int maxWidth, int filterSize, out HTuple histoValues)
		{
			IntPtr proc = HalconAPI.PreCall(54);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, refLineStartRow);
			HalconAPI.StoreI(proc, 1, refLineStartColumn);
			HalconAPI.StoreI(proc, 2, refLineEndRow);
			HalconAPI.StoreI(proc, 3, refLineEndColumn);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, maxWidth);
			HalconAPI.StoreI(proc, 6, filterSize);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 2, num, out selectedContours);
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out histoValues);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the union of neighboring straight contours that have a similar  direction.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="maxDist">Maximum distance of the contours' endpoints. Default: 5.0</param>
		/// <param name="maxDiff">Maximum difference in direction. Default: 0.5</param>
		/// <param name="percent">Weighting factor for the two selection criteria. Default: 50.0</param>
		/// <param name="mode">Should parallel contours be taken into account? Default: "noparallel"</param>
		/// <param name="iterations">Number of iterations or 'maximum'. Default: "maximum"</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001C22 RID: 7202 RVA: 0x000ADF44 File Offset: 0x000AC144
		public HXLDCont UnionStraightContoursXld(double maxDist, double maxDiff, double percent, string mode, HTuple iterations)
		{
			IntPtr proc = HalconAPI.PreCall(55);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maxDist);
			HalconAPI.StoreD(proc, 1, maxDiff);
			HalconAPI.StoreD(proc, 2, percent);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.Store(proc, 4, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(iterations);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the union of neighboring straight contours that have a similar  direction.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="maxDist">Maximum distance of the contours' endpoints. Default: 5.0</param>
		/// <param name="maxDiff">Maximum difference in direction. Default: 0.5</param>
		/// <param name="percent">Weighting factor for the two selection criteria. Default: 50.0</param>
		/// <param name="mode">Should parallel contours be taken into account? Default: "noparallel"</param>
		/// <param name="iterations">Number of iterations or 'maximum'. Default: "maximum"</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001C23 RID: 7203 RVA: 0x000ADFBC File Offset: 0x000AC1BC
		public HXLDCont UnionStraightContoursXld(double maxDist, double maxDiff, double percent, string mode, string iterations)
		{
			IntPtr proc = HalconAPI.PreCall(55);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maxDist);
			HalconAPI.StoreD(proc, 1, maxDiff);
			HalconAPI.StoreD(proc, 2, percent);
			HalconAPI.StoreS(proc, 3, mode);
			HalconAPI.StoreS(proc, 4, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the union of collinear contours  (operator with extended functionality).
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="maxDistAbs">Maximum distance of the contours' end points in the direction of the reference regression line. Default: 10.0</param>
		/// <param name="maxDistRel">Maximum distance of the contours' end points in the direction of the reference regression line in relation to the length of the contour which is to be elongated. Default: 1.0</param>
		/// <param name="maxShift">Maximum distance of the contour from the reference regression line (i.e., perpendicular to the line). Default: 2.0</param>
		/// <param name="maxAngle">Maximum angle difference between the two contours. Default: 0.1</param>
		/// <param name="maxOverlap">Maximum range of the overlap. Default: 0.0</param>
		/// <param name="maxRegrError">Maximum regression error of the resulting contours (NOT USED).  Default: -1.0</param>
		/// <param name="maxCosts">Threshold for reducing the total costs of unification. Default: 1.0</param>
		/// <param name="weightDist">Influence of the distance in the line direction on the total costs. Default: 1.0</param>
		/// <param name="weightShift">Influence of the distance from the regression line on the total costs. Default: 1.0</param>
		/// <param name="weightAngle">Influence of the angle difference on the total costs. Default: 1.0</param>
		/// <param name="weightLink">Influence of the line disturbance by the linking segment (overlap and angle difference) on the total costs. Default: 1.0</param>
		/// <param name="weightRegr">Influence of the regression error on the total costs (NOT USED). Default: 0.0</param>
		/// <param name="mode">Mode describing the treatment of the contours' attributes Default: "attr_keep"</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001C24 RID: 7204 RVA: 0x000AE02C File Offset: 0x000AC22C
		public HXLDCont UnionCollinearContoursExtXld(double maxDistAbs, double maxDistRel, double maxShift, double maxAngle, double maxOverlap, double maxRegrError, double maxCosts, double weightDist, double weightShift, double weightAngle, double weightLink, double weightRegr, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(56);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maxDistAbs);
			HalconAPI.StoreD(proc, 1, maxDistRel);
			HalconAPI.StoreD(proc, 2, maxShift);
			HalconAPI.StoreD(proc, 3, maxAngle);
			HalconAPI.StoreD(proc, 4, maxOverlap);
			HalconAPI.StoreD(proc, 5, maxRegrError);
			HalconAPI.StoreD(proc, 6, maxCosts);
			HalconAPI.StoreD(proc, 7, weightDist);
			HalconAPI.StoreD(proc, 8, weightShift);
			HalconAPI.StoreD(proc, 9, weightAngle);
			HalconAPI.StoreD(proc, 10, weightLink);
			HalconAPI.StoreD(proc, 11, weightRegr);
			HalconAPI.StoreS(proc, 12, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Unite approximately collinear contours.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="maxDistAbs">Maximum length of the gap between two contours, measured along the regression line of the reference contour. Default: 10.0</param>
		/// <param name="maxDistRel">Maximum length of the gap between two contours, relative to the length of the reference contour, both measured along the regression line of the reference contour. Default: 1.0</param>
		/// <param name="maxShift">Maximum distance of the second contour from the regression line of the reference contour. Default: 2.0</param>
		/// <param name="maxAngle">Maximum angle between the regression lines of two contours. Default: 0.1</param>
		/// <param name="mode">Mode that defines the treatment of contour attributes, i.e., if the contour attributes are kept or discarded. Default: "attr_keep"</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001C25 RID: 7205 RVA: 0x000AE0E8 File Offset: 0x000AC2E8
		public HXLDCont UnionCollinearContoursXld(double maxDistAbs, double maxDistRel, double maxShift, double maxAngle, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(57);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maxDistAbs);
			HalconAPI.StoreD(proc, 1, maxDistRel);
			HalconAPI.StoreD(proc, 2, maxShift);
			HalconAPI.StoreD(proc, 3, maxAngle);
			HalconAPI.StoreS(proc, 4, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the union of contours whose end points are close together.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="maxDistAbs">Maximum distance of the contours' end points. Default: 10.0</param>
		/// <param name="maxDistRel">Maximum distance of the contours' end points in relation to the length of the longer contour. Default: 1.0</param>
		/// <param name="mode">Mode describing the treatment of the contours' attributes. Default: "attr_keep"</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001C26 RID: 7206 RVA: 0x000AE158 File Offset: 0x000AC358
		public HXLDCont UnionAdjacentContoursXld(double maxDistAbs, double maxDistRel, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(58);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, maxDistAbs);
			HalconAPI.StoreD(proc, 1, maxDistRel);
			HalconAPI.StoreS(proc, 2, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select XLD contours according to several features.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="feature">Feature to select contours with. Default: "contour_length"</param>
		/// <param name="min1">Lower threshold. Default: 0.5</param>
		/// <param name="max1">Upper threshold. Default: 200.0</param>
		/// <param name="min2">Lower threshold. Default: -0.5</param>
		/// <param name="max2">Upper threshold. Default: 0.5</param>
		/// <returns>Output XLD contours.</returns>
		// Token: 0x06001C27 RID: 7207 RVA: 0x000AE1B8 File Offset: 0x000AC3B8
		public HXLDCont SelectContoursXld(string feature, double min1, double max1, double min2, double max2)
		{
			IntPtr proc = HalconAPI.PreCall(59);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, feature);
			HalconAPI.StoreD(proc, 1, min1);
			HalconAPI.StoreD(proc, 2, max1);
			HalconAPI.StoreD(proc, 3, min2);
			HalconAPI.StoreD(proc, 4, max2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return XLD contour parameters.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="nx">X-coordinate of the normal vector of the regression line.</param>
		/// <param name="ny">Y-coordinate of the normal vector of the regression line.</param>
		/// <param name="dist">Distance of the regression line from the origin.</param>
		/// <param name="fpx">X-coordinate of the projection of the start point of the contour onto the regression line.</param>
		/// <param name="fpy">Y-coordinate of the projection of the start point of the contour onto the regression line.</param>
		/// <param name="lpx">X-coordinate of the projection of the end point of the contour onto the regression line.</param>
		/// <param name="lpy">Y-coordinate of the projection of the end point of the contour onto the regression line.</param>
		/// <param name="mean">Mean distance of the contour points from the regression line.</param>
		/// <param name="deviation">Standard deviation of the distances from the regression line.</param>
		/// <returns>Number of contour points.</returns>
		// Token: 0x06001C28 RID: 7208 RVA: 0x000AE228 File Offset: 0x000AC428
		public HTuple GetRegressParamsXld(out HTuple nx, out HTuple ny, out HTuple dist, out HTuple fpx, out HTuple fpy, out HTuple lpx, out HTuple lpy, out HTuple mean, out HTuple deviation)
		{
			IntPtr proc = HalconAPI.PreCall(60);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out nx);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out ny);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out dist);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out fpx);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out fpy);
			num = HTuple.LoadNew(proc, 6, HTupleType.DOUBLE, num, out lpx);
			num = HTuple.LoadNew(proc, 7, HTupleType.DOUBLE, num, out lpy);
			num = HTuple.LoadNew(proc, 8, HTupleType.DOUBLE, num, out mean);
			num = HTuple.LoadNew(proc, 9, HTupleType.DOUBLE, num, out deviation);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the parameters of a regression line to an XLD contour.
		///   Instance represents: Input XLD contours.
		/// </summary>
		/// <param name="mode">Type of outlier treatment. Default: "no"</param>
		/// <param name="iterations">Number of iterations for the outlier treatment. Default: 1</param>
		/// <returns>Resulting XLD contours.</returns>
		// Token: 0x06001C29 RID: 7209 RVA: 0x000AE324 File Offset: 0x000AC524
		public HXLDCont RegressContoursXld(string mode, int iterations)
		{
			IntPtr proc = HalconAPI.PreCall(61);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.StoreI(proc, 1, iterations);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the direction of an XLD contour for each contour point.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="angleMode">Return type of the angles. Default: "abs"</param>
		/// <param name="calcMode">Method for computing the angles. Default: "range"</param>
		/// <param name="lookaround">Number of points to take into account. Default: 3</param>
		/// <returns>Direction of the tangent to the contour points.</returns>
		// Token: 0x06001C2A RID: 7210 RVA: 0x000AE37C File Offset: 0x000AC57C
		public HTuple GetContourAngleXld(string angleMode, string calcMode, int lookaround)
		{
			IntPtr proc = HalconAPI.PreCall(62);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, angleMode);
			HalconAPI.StoreS(proc, 1, calcMode);
			HalconAPI.StoreI(proc, 2, lookaround);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Smooth an XLD contour.
		///   Instance represents: Contour to be smoothed.
		/// </summary>
		/// <param name="numRegrPoints">Number of points used to calculate the regression line. Default: 5</param>
		/// <returns>Smoothed contour.</returns>
		// Token: 0x06001C2B RID: 7211 RVA: 0x000AE3DC File Offset: 0x000AC5DC
		public HXLDCont SmoothContoursXld(int numRegrPoints)
		{
			IntPtr proc = HalconAPI.PreCall(63);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numRegrPoints);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the number of points in an XLD contour.
		///   Instance represents: Input XLD contour.
		/// </summary>
		/// <returns>Number of contour points.</returns>
		// Token: 0x06001C2C RID: 7212 RVA: 0x000AE42C File Offset: 0x000AC62C
		public HTuple ContourPointNumXld()
		{
			IntPtr proc = HalconAPI.PreCall(64);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.INTEGER, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the names of the defined global attributes of an XLD contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <returns>List of the defined global contour attributes.</returns>
		// Token: 0x06001C2D RID: 7213 RVA: 0x000AE474 File Offset: 0x000AC674
		public HTuple QueryContourGlobalAttribsXld()
		{
			IntPtr proc = HalconAPI.PreCall(65);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return global attributes values of an XLD contour.
		///   Instance represents: Input XLD contour.
		/// </summary>
		/// <param name="name">Name of the attribute. Default: "regr_norm_row"</param>
		/// <returns>Attribute values.</returns>
		// Token: 0x06001C2E RID: 7214 RVA: 0x000AE4BC File Offset: 0x000AC6BC
		public HTuple GetContourGlobalAttribXld(HTuple name)
		{
			IntPtr proc = HalconAPI.PreCall(66);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, name);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(name);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return global attributes values of an XLD contour.
		///   Instance represents: Input XLD contour.
		/// </summary>
		/// <param name="name">Name of the attribute. Default: "regr_norm_row"</param>
		/// <returns>Attribute values.</returns>
		// Token: 0x06001C2F RID: 7215 RVA: 0x000AE510 File Offset: 0x000AC710
		public HTuple GetContourGlobalAttribXld(string name)
		{
			IntPtr proc = HalconAPI.PreCall(66);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, name);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the names of the defined attributes of an XLD contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <returns>List of the defined contour attributes.</returns>
		// Token: 0x06001C30 RID: 7216 RVA: 0x000AE560 File Offset: 0x000AC760
		public HTuple QueryContourAttribsXld()
		{
			IntPtr proc = HalconAPI.PreCall(67);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return point attribute values of an XLD contour.
		///   Instance represents: Input XLD contour.
		/// </summary>
		/// <param name="name">Name of the attribute. Default: "angle"</param>
		/// <returns>Attribute values.</returns>
		// Token: 0x06001C31 RID: 7217 RVA: 0x000AE5A8 File Offset: 0x000AC7A8
		public HTuple GetContourAttribXld(string name)
		{
			IntPtr proc = HalconAPI.PreCall(68);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, name);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the coordinates of an XLD contour.
		///   Instance represents: Input XLD contour.
		/// </summary>
		/// <param name="row">Row coordinate of the contour's points.</param>
		/// <param name="col">Column coordinate of the contour's points.</param>
		// Token: 0x06001C32 RID: 7218 RVA: 0x000AE5F8 File Offset: 0x000AC7F8
		public void GetContourXld(out HTuple row, out HTuple col)
		{
			IntPtr proc = HalconAPI.PreCall(69);
			base.Store(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out col);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate an XLD contour with rounded corners from a polygon (given as tuples).
		///   Modified instance represents: Resulting contour.
		/// </summary>
		/// <param name="row">Row coordinates of the polygon. Default: [20,80,80,20,20]</param>
		/// <param name="col">Column coordinates of the polygon. Default: [20,20,80,80,20]</param>
		/// <param name="radius">Radii of the rounded corners. Default: [20,20,20,20,20]</param>
		/// <param name="samplingInterval">Distance of the samples. Default: 1.0</param>
		// Token: 0x06001C33 RID: 7219 RVA: 0x000AE650 File Offset: 0x000AC850
		public void GenContourPolygonRoundedXld(HTuple row, HTuple col, HTuple radius, HTuple samplingInterval)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(71);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, col);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.Store(proc, 3, samplingInterval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(col);
			HalconAPI.UnpinTuple(radius);
			HalconAPI.UnpinTuple(samplingInterval);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate an XLD contour with rounded corners from a polygon (given as tuples).
		///   Modified instance represents: Resulting contour.
		/// </summary>
		/// <param name="row">Row coordinates of the polygon. Default: [20,80,80,20,20]</param>
		/// <param name="col">Column coordinates of the polygon. Default: [20,20,80,80,20]</param>
		/// <param name="radius">Radii of the rounded corners. Default: [20,20,20,20,20]</param>
		/// <param name="samplingInterval">Distance of the samples. Default: 1.0</param>
		// Token: 0x06001C34 RID: 7220 RVA: 0x000AE6CC File Offset: 0x000AC8CC
		public void GenContourPolygonRoundedXld(HTuple row, HTuple col, HTuple radius, double samplingInterval)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(71);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, col);
			HalconAPI.Store(proc, 2, radius);
			HalconAPI.StoreD(proc, 3, samplingInterval);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(col);
			HalconAPI.UnpinTuple(radius);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Generate an XLD contour from a polygon (given as tuples).
		///   Modified instance represents: Resulting contour.
		/// </summary>
		/// <param name="row">Row coordinates of the polygon. Default: [0,1,2,2,2]</param>
		/// <param name="col">Column coordinates of the polygon. Default: [0,0,0,1,2]</param>
		// Token: 0x06001C35 RID: 7221 RVA: 0x000AE740 File Offset: 0x000AC940
		public void GenContourPolygonXld(HTuple row, HTuple col)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(72);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, col);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(col);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the difference of two object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objectsSub">Object tuple 2.</param>
		/// <returns>Objects from Objects that are not part of ObjectsSub.</returns>
		// Token: 0x06001C36 RID: 7222 RVA: 0x000AE7A0 File Offset: 0x000AC9A0
		public HXLDCont ObjDiff(HXLDCont objectsSub)
		{
			IntPtr proc = HalconAPI.PreCall(573);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsSub);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsSub);
			return result;
		}

		/// <summary>
		///   Copy an iconic object in the HALCON database.
		///   Instance represents: Objects to be copied.
		/// </summary>
		/// <param name="index">Starting index of the objects to be copied. Default: 1</param>
		/// <param name="numObj">Number of objects to be copied or -1. Default: 1</param>
		/// <returns>Copied objects.</returns>
		// Token: 0x06001C37 RID: 7223 RVA: 0x000AE7F8 File Offset: 0x000AC9F8
		public new HXLDCont CopyObj(int index, int numObj)
		{
			IntPtr proc = HalconAPI.PreCall(583);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.StoreI(proc, 1, numObj);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Concatenate two iconic object tuples.
		///   Instance represents: Object tuple 1.
		/// </summary>
		/// <param name="objects2">Object tuple 2.</param>
		/// <returns>Concatenated objects.</returns>
		// Token: 0x06001C38 RID: 7224 RVA: 0x000AE850 File Offset: 0x000ACA50
		public HXLDCont ConcatObj(HXLDCont objects2)
		{
			IntPtr proc = HalconAPI.PreCall(584);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001C39 RID: 7225 RVA: 0x000AE8A8 File Offset: 0x000ACAA8
		public new HXLDCont SelectObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select objects from an object tuple.
		///   Instance represents: Input objects.
		/// </summary>
		/// <param name="index">Indices of the objects to be selected. Default: 1</param>
		/// <returns>Selected objects.</returns>
		// Token: 0x06001C3A RID: 7226 RVA: 0x000AE900 File Offset: 0x000ACB00
		public new HXLDCont SelectObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(587);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001C3B RID: 7227 RVA: 0x000AE950 File Offset: 0x000ACB50
		public int CompareObj(HXLDCont objects2, HTuple epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.Store(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(epsilon);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare iconic objects regarding equality.
		///   Instance represents: Reference objects.
		/// </summary>
		/// <param name="objects2">Test objects.</param>
		/// <param name="epsilon">Maximum allowed difference between two gray values or  coordinates etc. Default: 0.0</param>
		/// <returns>Boolean result value.</returns>
		// Token: 0x06001C3C RID: 7228 RVA: 0x000AE9B4 File Offset: 0x000ACBB4
		public int CompareObj(HXLDCont objects2, double epsilon)
		{
			IntPtr proc = HalconAPI.PreCall(588);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.StoreD(proc, 0, epsilon);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Compare image objects regarding equality.
		///   Instance represents: Test objects.
		/// </summary>
		/// <param name="objects2">Comparative objects.</param>
		/// <returns>boolean result value.</returns>
		// Token: 0x06001C3D RID: 7229 RVA: 0x000AEA14 File Offset: 0x000ACC14
		public int TestEqualObj(HXLDCont objects2)
		{
			IntPtr proc = HalconAPI.PreCall(591);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objects2);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objects2);
			return result;
		}

		/// <summary>
		///   Create a region from an XLD contour.
		///   Instance represents: Input contour(s).
		/// </summary>
		/// <param name="mode">Fill mode of the region(s). Default: "filled"</param>
		/// <returns>Created region(s).</returns>
		// Token: 0x06001C3E RID: 7230 RVA: 0x000AEA6C File Offset: 0x000ACC6C
		public HRegion GenRegionContourXld(string mode)
		{
			IntPtr proc = HalconAPI.PreCall(597);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HRegion result;
			num = HRegion.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C3F RID: 7231 RVA: 0x000AEABC File Offset: 0x000ACCBC
		public HShapeModel CreateAnisoShapeModelXld(HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleRMin, double scaleRMax, HTuple scaleRStep, double scaleCMin, double scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(935);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an anisotropically scaled shape model for matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in the row direction. Default: 0.9</param>
		/// <param name="scaleRMax">Maximum scale of the pattern in the row direction. Default: 1.1</param>
		/// <param name="scaleRStep">Scale step length (resolution) in the row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in the column direction. Default: 0.9</param>
		/// <param name="scaleCMax">Maximum scale of the pattern in the column direction. Default: 1.1</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C40 RID: 7232 RVA: 0x000AEB9C File Offset: 0x000ACD9C
		public HShapeModel CreateAnisoShapeModelXld(int numLevels, double angleStart, double angleExtent, double angleStep, double scaleRMin, double scaleRMax, double scaleRStep, double scaleCMin, double scaleCMax, double scaleCStep, string optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(935);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.StoreD(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.StoreD(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C41 RID: 7233 RVA: 0x000AEC5C File Offset: 0x000ACE5C
		public HShapeModel CreateScaledShapeModelXld(HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, double scaleMin, double scaleMax, HTuple scaleStep, HTuple optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(936);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.Store(proc, 6, scaleStep);
			HalconAPI.Store(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleStep);
			HalconAPI.UnpinTuple(optimization);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare an isotropically scaled shape model for matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleMin">Minimum scale of the pattern. Default: 0.9</param>
		/// <param name="scaleMax">Maximum scale of the pattern. Default: 1.1</param>
		/// <param name="scaleStep">Scale step length (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C42 RID: 7234 RVA: 0x000AED18 File Offset: 0x000ACF18
		public HShapeModel CreateScaledShapeModelXld(int numLevels, double angleStart, double angleExtent, double angleStep, double scaleMin, double scaleMax, double scaleStep, string optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(936);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleMin);
			HalconAPI.StoreD(proc, 5, scaleMax);
			HalconAPI.StoreD(proc, 6, scaleStep);
			HalconAPI.StoreS(proc, 7, optimization);
			HalconAPI.StoreS(proc, 8, metric);
			HalconAPI.StoreI(proc, 9, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a shape model for matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C43 RID: 7235 RVA: 0x000AEDB8 File Offset: 0x000ACFB8
		public HShapeModel CreateShapeModelXld(HTuple numLevels, double angleStart, double angleExtent, HTuple angleStep, HTuple optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(937);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.Store(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(optimization);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a shape model for matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">Smallest rotation of the pattern. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="optimization">Kind of optimization and optionally method used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C44 RID: 7236 RVA: 0x000AEE50 File Offset: 0x000AD050
		public HShapeModel CreateShapeModelXld(int numLevels, double angleStart, double angleExtent, double angleStep, string optimization, string metric, int minContrast)
		{
			IntPtr proc = HalconAPI.PreCall(937);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreS(proc, 4, optimization);
			HalconAPI.StoreS(proc, 5, metric);
			HalconAPI.StoreI(proc, 6, minContrast);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HShapeModel result;
			num = HShapeModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a deformable model for local deformable matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C45 RID: 7237 RVA: 0x000AEED4 File Offset: 0x000AD0D4
		public HDeformableModel CreateLocalDeformableModelXld(HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(975);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a deformable model for local deformable matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C46 RID: 7238 RVA: 0x000AEFF0 File Offset: 0x000AD1F0
		public HDeformableModel CreateLocalDeformableModelXld(int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(975);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a deformable model for planar calibrated matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C47 RID: 7239 RVA: 0x000AF0EC File Offset: 0x000AD2EC
		public HDeformableModel CreatePlanarCalibDeformableModelXld(HCamPar camParam, HPose referencePose, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(976);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.Store(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.Store(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.Store(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.Store(proc, 11, scaleCStep);
			HalconAPI.Store(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.StoreI(proc, 14, minContrast);
			HalconAPI.Store(proc, 15, genParamName);
			HalconAPI.Store(proc, 16, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a deformable model for planar calibrated matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C48 RID: 7240 RVA: 0x000AF240 File Offset: 0x000AD440
		public HDeformableModel CreatePlanarCalibDeformableModelXld(HCamPar camParam, HPose referencePose, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(976);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.StoreI(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.StoreD(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.StoreD(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.StoreD(proc, 11, scaleCStep);
			HalconAPI.StoreS(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.StoreI(proc, 14, minContrast);
			HalconAPI.Store(proc, 15, genParamName);
			HalconAPI.Store(proc, 16, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a deformable model for planar uncalibrated matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C49 RID: 7241 RVA: 0x000AF370 File Offset: 0x000AD570
		public HDeformableModel CreatePlanarUncalibDeformableModelXld(HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(977);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Prepare a deformable model for planar uncalibrated matching from XLD contours.
		///   Instance represents: Input contours that will be used to create the model.
		/// </summary>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		/// <returns>Handle of the model.</returns>
		// Token: 0x06001C4A RID: 7242 RVA: 0x000AF48C File Offset: 0x000AD68C
		public HDeformableModel CreatePlanarUncalibDeformableModelXld(int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(977);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HDeformableModel result;
			num = HDeformableModel.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001C4B RID: 7243 RVA: 0x000AF588 File Offset: 0x000AD788
		public HImage GenGridRectificationMap(HImage image, out HXLDCont meshes, int gridSpacing, HTuple rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.Store(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rotation);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Compute the mapping between the distorted image and the rectified image based upon the points of a regular grid.
		///   Instance represents: Input contours.
		/// </summary>
		/// <param name="image">Input image.</param>
		/// <param name="meshes">Output contours.</param>
		/// <param name="gridSpacing">Distance of the grid points in the rectified image.</param>
		/// <param name="rotation">Rotation to be applied to the point grid. Default: "auto"</param>
		/// <param name="row">Row coordinates of the grid points.</param>
		/// <param name="column">Column coordinates of the grid points.</param>
		/// <param name="mapType">Type of mapping. Default: "bilinear"</param>
		/// <returns>Image containing the mapping data.</returns>
		// Token: 0x06001C4C RID: 7244 RVA: 0x000AF634 File Offset: 0x000AD834
		public HImage GenGridRectificationMap(HImage image, out HXLDCont meshes, int gridSpacing, string rotation, HTuple row, HTuple column, string mapType)
		{
			IntPtr proc = HalconAPI.PreCall(1159);
			base.Store(proc, 2);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreI(proc, 0, gridSpacing);
			HalconAPI.StoreS(proc, 1, rotation);
			HalconAPI.Store(proc, 2, row);
			HalconAPI.Store(proc, 3, column);
			HalconAPI.StoreS(proc, 4, mapType);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HXLDCont.LoadNew(proc, 2, num, out meshes);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Interactive modification of a NURBS curve using interpolation.
		///   Modified instance represents: Contour of the modified curve.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="edit">Enable editing? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 5. Default: 3</param>
		/// <param name="rowsIn">Row coordinates of the input interpolation points.</param>
		/// <param name="colsIn">Column coordinates of the input interpolation points.</param>
		/// <param name="tangentsIn">Input tangents.</param>
		/// <param name="controlRows">Row coordinates of the control polygon.</param>
		/// <param name="controlCols">Column coordinates of the control polygon.</param>
		/// <param name="knots">Knot vector.</param>
		/// <param name="rows">Row coordinates of the points specified by the user.</param>
		/// <param name="cols">Column coordinates of the points specified by the user.</param>
		/// <param name="tangents">Tangents specified by the user.</param>
		// Token: 0x06001C4D RID: 7245 RVA: 0x000AF6D8 File Offset: 0x000AD8D8
		public void DrawNurbsInterpMod(HWindow windowHandle, string rotate, string move, string scale, string keepRatio, string edit, int degree, HTuple rowsIn, HTuple colsIn, HTuple tangentsIn, out HTuple controlRows, out HTuple controlCols, out HTuple knots, out HTuple rows, out HTuple cols, out HTuple tangents)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1318);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreS(proc, 5, edit);
			HalconAPI.StoreI(proc, 6, degree);
			HalconAPI.Store(proc, 7, rowsIn);
			HalconAPI.Store(proc, 8, colsIn);
			HalconAPI.Store(proc, 9, tangentsIn);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowsIn);
			HalconAPI.UnpinTuple(colsIn);
			HalconAPI.UnpinTuple(tangentsIn);
			num = base.Load(proc, 1, num);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out controlRows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out controlCols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out knots);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out tangents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Interactive drawing of a NURBS curve using interpolation.
		///   Modified instance represents: Contour of the curve.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 5. Default: 3</param>
		/// <param name="controlRows">Row coordinates of the control polygon.</param>
		/// <param name="controlCols">Column coordinates of the control polygon.</param>
		/// <param name="knots">Knot vector.</param>
		/// <param name="rows">Row coordinates of the points specified by the user.</param>
		/// <param name="cols">Column coordinates of the points specified by the user.</param>
		/// <param name="tangents">Tangents specified by the user.</param>
		// Token: 0x06001C4E RID: 7246 RVA: 0x000AF808 File Offset: 0x000ADA08
		public void DrawNurbsInterp(HWindow windowHandle, string rotate, string move, string scale, string keepRatio, int degree, out HTuple controlRows, out HTuple controlCols, out HTuple knots, out HTuple rows, out HTuple cols, out HTuple tangents)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1319);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreI(proc, 5, degree);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out controlRows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out controlCols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out knots);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 5, HTupleType.DOUBLE, num, out tangents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Interactive modification of a NURBS curve.
		///   Modified instance represents: Contour of the modified curve.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="edit">Enable editing? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 25. Default: 3</param>
		/// <param name="rowsIn">Row coordinates of the input control polygon.</param>
		/// <param name="colsIn">Column coordinates of the input control polygon.</param>
		/// <param name="weightsIn">Input weight vector.</param>
		/// <param name="rows">Row coordinates of the control polygon.</param>
		/// <param name="cols">Columns coordinates of the control polygon.</param>
		/// <param name="weights">Weight vector.</param>
		// Token: 0x06001C4F RID: 7247 RVA: 0x000AF900 File Offset: 0x000ADB00
		public void DrawNurbsMod(HWindow windowHandle, string rotate, string move, string scale, string keepRatio, string edit, int degree, HTuple rowsIn, HTuple colsIn, HTuple weightsIn, out HTuple rows, out HTuple cols, out HTuple weights)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1320);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreS(proc, 5, edit);
			HalconAPI.StoreI(proc, 6, degree);
			HalconAPI.Store(proc, 7, rowsIn);
			HalconAPI.Store(proc, 8, colsIn);
			HalconAPI.Store(proc, 9, weightsIn);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(rowsIn);
			HalconAPI.UnpinTuple(colsIn);
			HalconAPI.UnpinTuple(weightsIn);
			num = base.Load(proc, 1, num);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out weights);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Interactive drawing of a NURBS curve.
		///   Modified instance represents: Contour approximating the NURBS curve.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="degree">The degree $p$ of the NURBS curve. Reasonable values are 3 to 25. Default: 3</param>
		/// <param name="rows">Row coordinates of the control polygon.</param>
		/// <param name="cols">Columns coordinates of the control polygon.</param>
		/// <param name="weights">Weight vector.</param>
		// Token: 0x06001C50 RID: 7248 RVA: 0x000AF9F4 File Offset: 0x000ADBF4
		public void DrawNurbs(HWindow windowHandle, string rotate, string move, string scale, string keepRatio, int degree, out HTuple rows, out HTuple cols, out HTuple weights)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1321);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreI(proc, 5, degree);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out rows);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cols);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out weights);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Interactive modification of a contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		/// <param name="edit">Enable editing? Default: "true"</param>
		/// <returns>Modified contour.</returns>
		// Token: 0x06001C51 RID: 7249 RVA: 0x000AFAB0 File Offset: 0x000ADCB0
		public HXLDCont DrawXldMod(HWindow windowHandle, string rotate, string move, string scale, string keepRatio, string edit)
		{
			IntPtr proc = HalconAPI.PreCall(1322);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.StoreS(proc, 5, edit);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
			return result;
		}

		/// <summary>
		///   Interactive drawing of a contour.
		///   Modified instance represents: Modified contour.
		/// </summary>
		/// <param name="windowHandle">Window handle.</param>
		/// <param name="rotate">Enable rotation? Default: "true"</param>
		/// <param name="move">Enable moving? Default: "true"</param>
		/// <param name="scale">Enable scaling? Default: "true"</param>
		/// <param name="keepRatio">Keep ratio while scaling? Default: "true"</param>
		// Token: 0x06001C52 RID: 7250 RVA: 0x000AFB34 File Offset: 0x000ADD34
		public void DrawXld(HWindow windowHandle, string rotate, string move, string scale, string keepRatio)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1323);
			HalconAPI.Store(proc, 0, windowHandle);
			HalconAPI.StoreS(proc, 1, rotate);
			HalconAPI.StoreS(proc, 2, move);
			HalconAPI.StoreS(proc, 3, scale);
			HalconAPI.StoreS(proc, 4, keepRatio);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(windowHandle);
		}

		/// <summary>
		///   Calculate the pointwise distance from one contour to another.
		///   Instance represents: Contours for whose points the distances are calculated.
		/// </summary>
		/// <param name="contourTo">Contours to which the distances are calculated to.</param>
		/// <param name="mode">Compute the distance to points ('point_to_point') or to entire segments ('point_to_segment'). Default: "point_to_point"</param>
		/// <returns>Copy of ContourFrom containing the distances as an attribute.</returns>
		// Token: 0x06001C53 RID: 7251 RVA: 0x000AFBA8 File Offset: 0x000ADDA8
		public HXLDCont DistanceContoursXld(HXLDCont contourTo, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1361);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contourTo);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contourTo);
			return result;
		}

		/// <summary>
		///   Calculate the minimum distance between two contours.
		///   Instance represents: First input contour.
		/// </summary>
		/// <param name="contour2">Second input contour.</param>
		/// <param name="mode">Distance calculation mode. Default: "fast_point_to_segment"</param>
		/// <returns>Minimum distance between the two contours.</returns>
		// Token: 0x06001C54 RID: 7252 RVA: 0x000AFC08 File Offset: 0x000ADE08
		public HTuple DistanceCcMin(HXLDCont contour2, string mode)
		{
			IntPtr proc = HalconAPI.PreCall(1362);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contour2);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contour2);
			return result;
		}

		/// <summary>
		///   Calculate the distance between two contours.
		///   Instance represents: First input contour.
		/// </summary>
		/// <param name="contour2">Second input contour.</param>
		/// <param name="mode">Distance calculation mode. Default: "point_to_point"</param>
		/// <param name="distanceMin">Minimum distance between both contours.</param>
		/// <param name="distanceMax">Maximum distance between both contours.</param>
		// Token: 0x06001C55 RID: 7253 RVA: 0x000AFC68 File Offset: 0x000ADE68
		public void DistanceCc(HXLDCont contour2, string mode, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1363);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contour2);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contour2);
		}

		/// <summary>
		///   Calculate the distance between two contours.
		///   Instance represents: First input contour.
		/// </summary>
		/// <param name="contour2">Second input contour.</param>
		/// <param name="mode">Distance calculation mode. Default: "point_to_point"</param>
		/// <param name="distanceMin">Minimum distance between both contours.</param>
		/// <param name="distanceMax">Maximum distance between both contours.</param>
		// Token: 0x06001C56 RID: 7254 RVA: 0x000AFCDC File Offset: 0x000ADEDC
		public void DistanceCc(HXLDCont contour2, string mode, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1363);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contour2);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contour2);
		}

		/// <summary>
		///   Calculate the distance between a line segment and one contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line segment.</param>
		/// <param name="column1">Column coordinate of the first point of the line segment.</param>
		/// <param name="row2">Row coordinate of the second point of the line segment.</param>
		/// <param name="column2">Column coordinate of the second point of the line segment.</param>
		/// <param name="distanceMin">Minimum distance between the line segment and the contour.</param>
		/// <param name="distanceMax">Maximum distance between the line segment and the contour.</param>
		// Token: 0x06001C57 RID: 7255 RVA: 0x000AFD4C File Offset: 0x000ADF4C
		public void DistanceSc(HTuple row1, HTuple column1, HTuple row2, HTuple column2, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1364);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a line segment and one contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line segment.</param>
		/// <param name="column1">Column coordinate of the first point of the line segment.</param>
		/// <param name="row2">Row coordinate of the second point of the line segment.</param>
		/// <param name="column2">Column coordinate of the second point of the line segment.</param>
		/// <param name="distanceMin">Minimum distance between the line segment and the contour.</param>
		/// <param name="distanceMax">Maximum distance between the line segment and the contour.</param>
		// Token: 0x06001C58 RID: 7256 RVA: 0x000AFDE4 File Offset: 0x000ADFE4
		public void DistanceSc(double row1, double column1, double row2, double column2, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1364);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a line and one contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line and the contour.</param>
		/// <param name="distanceMax">Maximum distance between the line and the contour.</param>
		// Token: 0x06001C59 RID: 7257 RVA: 0x000AFE60 File Offset: 0x000AE060
		public void DistanceLc(HTuple row1, HTuple column1, HTuple row2, HTuple column2, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1365);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row1);
			HalconAPI.Store(proc, 1, column1);
			HalconAPI.Store(proc, 2, row2);
			HalconAPI.Store(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row1);
			HalconAPI.UnpinTuple(column1);
			HalconAPI.UnpinTuple(row2);
			HalconAPI.UnpinTuple(column2);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a line and one contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row1">Row coordinate of the first point of the line.</param>
		/// <param name="column1">Column coordinate of the first point of the line.</param>
		/// <param name="row2">Row coordinate of the second point of the line.</param>
		/// <param name="column2">Column coordinate of the second point of the line.</param>
		/// <param name="distanceMin">Minimum distance between the line and the contour.</param>
		/// <param name="distanceMax">Maximum distance between the line and the contour.</param>
		// Token: 0x06001C5A RID: 7258 RVA: 0x000AFEF8 File Offset: 0x000AE0F8
		public void DistanceLc(double row1, double column1, double row2, double column2, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1365);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row1);
			HalconAPI.StoreD(proc, 1, column1);
			HalconAPI.StoreD(proc, 2, row2);
			HalconAPI.StoreD(proc, 3, column2);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a point and one contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column coordinate of the point.</param>
		/// <param name="distanceMin">Minimum distance between the point and the contour.</param>
		/// <param name="distanceMax">Maximum distance between the point and the contour.</param>
		// Token: 0x06001C5B RID: 7259 RVA: 0x000AFF74 File Offset: 0x000AE174
		public void DistancePc(HTuple row, HTuple column, out HTuple distanceMin, out HTuple distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1366);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out distanceMin);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Calculate the distance between a point and one contour.
		///   Instance represents: Input contour.
		/// </summary>
		/// <param name="row">Row coordinate of the point.</param>
		/// <param name="column">Column coordinate of the point.</param>
		/// <param name="distanceMin">Minimum distance between the point and the contour.</param>
		/// <param name="distanceMax">Maximum distance between the point and the contour.</param>
		// Token: 0x06001C5C RID: 7260 RVA: 0x000AFFEC File Offset: 0x000AE1EC
		public void DistancePc(double row, double column, out double distanceMin, out double distanceMax)
		{
			IntPtr proc = HalconAPI.PreCall(1366);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out distanceMin);
			num = HalconAPI.LoadD(proc, 1, num, out distanceMax);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Read XLD contours from a DXF file.
		///   Modified instance represents: Read XLD contours.
		/// </summary>
		/// <param name="fileName">Name of the DXF file.</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the DXF input. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the DXF input. Default: []</param>
		/// <returns>Status information.</returns>
		// Token: 0x06001C5D RID: 7261 RVA: 0x000B0058 File Offset: 0x000AE258
		public HTuple ReadContourXldDxf(string fileName, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1636);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 1, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read XLD contours from a DXF file.
		///   Modified instance represents: Read XLD contours.
		/// </summary>
		/// <param name="fileName">Name of the DXF file.</param>
		/// <param name="genParamName">Names of the generic parameters that can be adjusted for the DXF input. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters that can be adjusted for the DXF input. Default: []</param>
		/// <returns>Status information.</returns>
		// Token: 0x06001C5E RID: 7262 RVA: 0x000B00D4 File Offset: 0x000AE2D4
		public string ReadContourXldDxf(string fileName, string genParamName, double genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(1636);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.StoreD(proc, 2, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 1, num);
			string result;
			num = HalconAPI.LoadS(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Write XLD contours to a file in DXF format.
		///   Instance represents: XLD contours to be written.
		/// </summary>
		/// <param name="fileName">Name of the DXF file.</param>
		// Token: 0x06001C5F RID: 7263 RVA: 0x000B0144 File Offset: 0x000AE344
		public void WriteContourXldDxf(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(1637);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001C60 RID: 7264 RVA: 0x000B0180 File Offset: 0x000AE380
		public new HXLDCont SelectXldPoint(HTuple row, HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, row);
			HalconAPI.Store(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(row);
			HalconAPI.UnpinTuple(column);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Choose all contours or polygons containing a given point.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="row">Line coordinate of the test point. Default: 100.0</param>
		/// <param name="column">Column coordinate of the test point. Default: 100.0</param>
		/// <returns>All contours or polygons containing the test point.</returns>
		// Token: 0x06001C61 RID: 7265 RVA: 0x000B01E4 File Offset: 0x000AE3E4
		public new HXLDCont SelectXldPoint(double row, double column)
		{
			IntPtr proc = HalconAPI.PreCall(1676);
			base.Store(proc, 1);
			HalconAPI.StoreD(proc, 0, row);
			HalconAPI.StoreD(proc, 1, column);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001C62 RID: 7266 RVA: 0x000B023C File Offset: 0x000AE43C
		public new HXLDCont SelectShapeXld(HTuple features, string operation, HTuple min, HTuple max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.Store(proc, 2, min);
			HalconAPI.Store(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(min);
			HalconAPI.UnpinTuple(max);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select contours or polygons using shape features.
		///   Instance represents: Contours or polygons to be examined.
		/// </summary>
		/// <param name="features">Shape features to be checked. Default: "area"</param>
		/// <param name="operation">Operation type between the individual features. Default: "and"</param>
		/// <param name="min">Lower limits of the features or 'min'. Default: 150.0</param>
		/// <param name="max">Upper limits of the features or 'max'. Default: 99999.0</param>
		/// <returns>Contours or polygons fulfilling the condition(s).</returns>
		// Token: 0x06001C63 RID: 7267 RVA: 0x000B02B8 File Offset: 0x000AE4B8
		public new HXLDCont SelectShapeXld(string features, string operation, double min, double max)
		{
			IntPtr proc = HalconAPI.PreCall(1678);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, features);
			HalconAPI.StoreS(proc, 1, operation);
			HalconAPI.StoreD(proc, 2, min);
			HalconAPI.StoreD(proc, 3, max);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform the shape of contours or polygons.
		///   Instance represents: Contours or polygons to be transformed.
		/// </summary>
		/// <param name="type">Type of transformation. Default: "convex"</param>
		/// <returns>Transformed contours respectively polygons.</returns>
		// Token: 0x06001C64 RID: 7268 RVA: 0x000B0324 File Offset: 0x000AE524
		public new HXLDCont ShapeTransXld(string type)
		{
			IntPtr proc = HalconAPI.PreCall(1689);
			base.Store(proc, 1);
			HalconAPI.StoreS(proc, 0, type);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calibrate the radial distortion.
		///   Instance represents: Contours that are available for the calibration.
		/// </summary>
		/// <param name="width">Width of the images from which the contours were extracted. Default: 640</param>
		/// <param name="height">Height of the images from which the contours were extracted. Default: 480</param>
		/// <param name="inlierThreshold">Threshold for the classification of outliers. Default: 0.05</param>
		/// <param name="randSeed">Seed value for the random number generator. Default: 42</param>
		/// <param name="distortionModel">Determines the distortion model. Default: "division"</param>
		/// <param name="distortionCenter">Determines how the distortion center will be estimated. Default: "variable"</param>
		/// <param name="principalPointVar">Controls the deviation of the distortion center from the image center; larger values allow larger deviations from the image center; 0 switches the penalty term off. Default: 0.0</param>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <returns>Contours that were used for the calibration</returns>
		// Token: 0x06001C65 RID: 7269 RVA: 0x000B0374 File Offset: 0x000AE574
		public HXLDCont RadialDistortionSelfCalibration(int width, int height, double inlierThreshold, int randSeed, string distortionModel, string distortionCenter, double principalPointVar, out HCamPar cameraParam)
		{
			IntPtr proc = HalconAPI.PreCall(1904);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, width);
			HalconAPI.StoreI(proc, 1, height);
			HalconAPI.StoreD(proc, 2, inlierThreshold);
			HalconAPI.StoreI(proc, 3, randSeed);
			HalconAPI.StoreS(proc, 4, distortionModel);
			HalconAPI.StoreS(proc, 5, distortionCenter);
			HalconAPI.StoreD(proc, 6, principalPointVar);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			num = HCamPar.LoadNew(proc, 0, num, out cameraParam);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an XLD contour into the plane z=0 of a world coordinate system.
		///   Instance represents: Input XLD contours to be transformed in image coordinates.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="worldPose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="scale">Scale or dimension Default: "m"</param>
		/// <returns>Transformed XLD contours in world coordinates.</returns>
		// Token: 0x06001C66 RID: 7270 RVA: 0x000B040C File Offset: 0x000AE60C
		public HXLDCont ContourToWorldPlaneXld(HTuple cameraParam, HPose worldPose, HTuple scale)
		{
			IntPtr proc = HalconAPI.PreCall(1915);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, worldPose);
			HalconAPI.Store(proc, 2, scale);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(worldPose);
			HalconAPI.UnpinTuple(scale);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Transform an XLD contour into the plane z=0 of a world coordinate system.
		///   Instance represents: Input XLD contours to be transformed in image coordinates.
		/// </summary>
		/// <param name="cameraParam">Internal camera parameters.</param>
		/// <param name="worldPose">3D pose of the world coordinate system in camera coordinates.</param>
		/// <param name="scale">Scale or dimension Default: "m"</param>
		/// <returns>Transformed XLD contours in world coordinates.</returns>
		// Token: 0x06001C67 RID: 7271 RVA: 0x000B0488 File Offset: 0x000AE688
		public HXLDCont ContourToWorldPlaneXld(HTuple cameraParam, HPose worldPose, string scale)
		{
			IntPtr proc = HalconAPI.PreCall(1915);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, cameraParam);
			HalconAPI.Store(proc, 1, worldPose);
			HalconAPI.StoreS(proc, 2, scale);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(cameraParam);
			HalconAPI.UnpinTuple(worldPose);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Change the radial distortion of contours.
		///   Instance represents: Original contours.
		/// </summary>
		/// <param name="camParamIn">Internal camera parameter for Contours.</param>
		/// <param name="camParamOut">Internal camera parameter for ContoursRectified.</param>
		/// <returns>Resulting contours with modified radial distortion.</returns>
		// Token: 0x06001C68 RID: 7272 RVA: 0x000B0500 File Offset: 0x000AE700
		public HXLDCont ChangeRadialDistortionContoursXld(HCamPar camParamIn, HCamPar camParamOut)
		{
			IntPtr proc = HalconAPI.PreCall(1922);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, camParamIn);
			HalconAPI.Store(proc, 1, camParamOut);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParamIn);
			HalconAPI.UnpinTuple(camParamOut);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Calculate the minimum distance between two contours and the points used for  the calculation.
		///   Instance represents: First input contour.
		/// </summary>
		/// <param name="contour2">Second input contour.</param>
		/// <param name="mode">Distance calculation mode. Default: "fast_point_to_segment"</param>
		/// <param name="row1">Row coordinate of the point on Contour1.</param>
		/// <param name="column1">Column coordinate of the point on Contour1.</param>
		/// <param name="row2">Row coordinate of the point on Contour2.</param>
		/// <param name="column2">Column coordinate of the point on Contour2.</param>
		/// <returns>Minimum distance between the two contours.</returns>
		// Token: 0x06001C69 RID: 7273 RVA: 0x000B0578 File Offset: 0x000AE778
		public HTuple DistanceCcMinPoints(HXLDCont contour2, string mode, out HTuple row1, out HTuple column1, out HTuple row2, out HTuple column2)
		{
			IntPtr proc = HalconAPI.PreCall(2111);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contour2);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row1);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column1);
			num = HTuple.LoadNew(proc, 3, HTupleType.DOUBLE, num, out row2);
			num = HTuple.LoadNew(proc, 4, HTupleType.DOUBLE, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contour2);
			return result;
		}

		/// <summary>
		///   Calculate the minimum distance between two contours and the points used for  the calculation.
		///   Instance represents: First input contour.
		/// </summary>
		/// <param name="contour2">Second input contour.</param>
		/// <param name="mode">Distance calculation mode. Default: "fast_point_to_segment"</param>
		/// <param name="row1">Row coordinate of the point on Contour1.</param>
		/// <param name="column1">Column coordinate of the point on Contour1.</param>
		/// <param name="row2">Row coordinate of the point on Contour2.</param>
		/// <param name="column2">Column coordinate of the point on Contour2.</param>
		/// <returns>Minimum distance between the two contours.</returns>
		// Token: 0x06001C6A RID: 7274 RVA: 0x000B0628 File Offset: 0x000AE828
		public double DistanceCcMinPoints(HXLDCont contour2, string mode, out double row1, out double column1, out double row2, out double column2)
		{
			IntPtr proc = HalconAPI.PreCall(2111);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, contour2);
			HalconAPI.StoreS(proc, 0, mode);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			int num = HalconAPI.CallProcedure(proc);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			num = HalconAPI.LoadD(proc, 1, num, out row1);
			num = HalconAPI.LoadD(proc, 2, num, out column1);
			num = HalconAPI.LoadD(proc, 3, num, out row2);
			num = HalconAPI.LoadD(proc, 4, num, out column2);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contour2);
			return result;
		}

		/// <summary>
		///   Insert objects into an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="objectsInsert">Object tuple to insert.</param>
		/// <param name="index">Index to insert objects.</param>
		/// <returns>Extended object tuple.</returns>
		// Token: 0x06001C6B RID: 7275 RVA: 0x000B06D4 File Offset: 0x000AE8D4
		public HXLDCont InsertObj(HXLDCont objectsInsert, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2121);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsInsert);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsInsert);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001C6C RID: 7276 RVA: 0x000B0734 File Offset: 0x000AE934
		public new HXLDCont RemoveObj(HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Remove objects from an iconic object tuple.
		///   Instance represents: Input object tuple.
		/// </summary>
		/// <param name="index">Indices of the objects to be removed.</param>
		/// <returns>Remaining object tuple.</returns>
		// Token: 0x06001C6D RID: 7277 RVA: 0x000B078C File Offset: 0x000AE98C
		public new HXLDCont RemoveObj(int index)
		{
			IntPtr proc = HalconAPI.PreCall(2124);
			base.Store(proc, 1);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001C6E RID: 7278 RVA: 0x000B07DC File Offset: 0x000AE9DC
		public HXLDCont ReplaceObj(HXLDCont objectsReplace, HTuple index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.Store(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(index);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}

		/// <summary>
		///   Replaces one or more elements of an iconic object tuple.
		///   Instance represents: Iconic Input Object.
		/// </summary>
		/// <param name="objectsReplace">Element(s) to replace.</param>
		/// <param name="index">Index/Indices of elements to be replaced.</param>
		/// <returns>Tuple with replaced elements.</returns>
		// Token: 0x06001C6F RID: 7279 RVA: 0x000B0840 File Offset: 0x000AEA40
		public HXLDCont ReplaceObj(HXLDCont objectsReplace, int index)
		{
			IntPtr proc = HalconAPI.PreCall(2125);
			base.Store(proc, 1);
			HalconAPI.Store(proc, 2, objectsReplace);
			HalconAPI.StoreI(proc, 0, index);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(objectsReplace);
			return result;
		}
	}
}
